 /*
  * UAE - The Un*x Amiga Emulator
  *
  * Floppy disk emulation
  *
  * Copyright 1995 Hannu Rummukainen
  * Copyright 1995-2001 Bernd Schmidt
  * Copyright 2000-2003 Toni Wilen
  *
  * High Density Drive Handling by Dr. Adil Temel (C) 2001 [atemel1@hotmail.com]
  *
  */

#include "sysconfig.h"
#include "sysdeps.h"

#include "uae.h"
#include "options.h"
#include "memory.h"
#include "events.h"
#include "custom.h"
#include "custom_private.h"
#include "ersatz.h"
#include "disk.h"
#include "gui.h"
#include "zfile.h"
#include "newcpu.h"
#include "osemu.h"
#include "execlib.h"
#include "savestate.h"
#include "cia.h"
#include "debug.h"
#ifdef FDI2RAW
#include "fdi2raw.h"
#endif
#include "catweasel.h"
#include "driveclick.h"
#include "fsdb.h"
#ifdef CAPS
#ifdef _WIN32
#include "caps/caps_win32.h"
#else
#include "caps.h"
#endif
#endif
#include "crc32.h"

#include <ctype.h>

static int longwritemode = 0;

/* support HD floppies */
#define FLOPPY_DRIVE_HD
/* writable track length with normal 2us bitcell/300RPM motor (PAL) */
#define FLOPPY_WRITE_LEN (currprefs.ntscmode ? (12798 / 2) : (12668 / 2)) /* 12667 PAL, 12797 NTSC */
#define FLOPPY_WRITE_MAXLEN 0x3800
/* This works out to 350 */
#define FLOPPY_GAP_LEN (FLOPPY_WRITE_LEN - 11 * 544)
/* (cycles/bitcell) << 8, normal = ((2us/280ns)<<8) = ~1830 */
#define NORMAL_FLOPPY_SPEED (currprefs.ntscmode ? 1810 : 1829)
/* max supported floppy drives, for small memory systems */
#define MAX_FLOPPY_DRIVES 4

#ifdef FLOPPY_DRIVE_HD
#define DDHDMULT 2
#else
#define DDHDMULT 1
#endif

#undef DEBUG_DRIVE_ID


/* UAE-1ADF (ADF_EXT2)
 * W reserved
 * W number of tracks (default 2*80=160)
 *
 * W reserved
 * W type, 0=normal AmigaDOS track, 1 = raw MFM
 * L available space for track in bytes (must be even)
 * L track length in bits
 */

static int side, direction;
static uae_u8 selected = 15, disabled;

static uae_u8 writebuffer[544 * 11 * DDHDMULT];

#define DISK_INDEXSYNC 1
#define DISK_WORDSYNC 2
#define DISK_MOTORDELAY 4
#define DISK_REVOLUTION 8 /* 8,16,32,64 */

#define DSKREADY_TIME 4
#define DSKREADY_DOWN_TIME 10

static int diskevent_flag;
static int disk_sync_cycle;

#if 0
#define MAX_DISK_WORDS_PER_LINE 50 /* depends on floppy_speed */
static uae_u32 dma_tab[MAX_DISK_WORDS_PER_LINE + 1];
#endif
static int dskdmaen, dsklength, dsklength2, dsklen;
static uae_u16 dskbytr_val;
static uae_u32 dskpt;
static int dma_enable, bitoffset;
static uae_u16 word, dsksync;
/* Always carried through to the next line.  */
static unsigned int disk_hpos;
static int disk_jitter;

typedef enum { TRACK_AMIGADOS, TRACK_RAW, TRACK_RAW1, TRACK_PCDOS } image_tracktype;
typedef struct {
    uae_u16 len;
    uae_u32 offs;
    unsigned int bitlen, track;
    unsigned int sync;
    image_tracktype type;
} trackid;

#define MAX_TRACKS (2 * 83)

/* We have three kinds of Amiga floppy drives
 * - internal A500/A2000 drive:
 *   ID is always DRIVE_ID_NONE (S.T.A.G expects this)
 * - HD drive (A3000/A4000):
 *   ID is DRIVE_ID_35DD if DD floppy is inserted or drive is empty
 *   ID is DRIVE_ID_35HD if HD floppy is inserted
 * - regular external drive:
 *   ID is always DRIVE_ID_35DD
 */

#define DRIVE_ID_NONE  0x00000000
#define DRIVE_ID_35DD  0xFFFFFFFF
#define DRIVE_ID_35HD  0xAAAAAAAA
#define DRIVE_ID_525SD 0x55555555 /* 40 track 5.25 drive , kickstart does not recognize this */

typedef enum { ADF_NORMAL, ADF_EXT1, ADF_EXT2, ADF_FDI, ADF_IPF, ADF_CATWEASEL, ADF_PCDOS } drive_filetype;
typedef struct {
    struct zfile *diskfile;
    struct zfile *writediskfile;
    drive_filetype filetype;
    trackid trackdata[MAX_TRACKS];
    trackid writetrackdata[MAX_TRACKS];
    int buffered_cyl, buffered_side;
    unsigned int cyl;
    int motoroff;
    int motordelay; /* dskrdy needs some clock cycles before it changes after switching off motor */
    int state;
    int wrprot;
    uae_u16 bigmfmbuf[0x4000 * DDHDMULT];
    uae_u16 tracktiming[0x4000 * DDHDMULT];
    int multi_revolution;
    int skipoffset;
    unsigned int mfmpos;
    unsigned int indexoffset;
    unsigned int tracklen;
    unsigned int prevtracklen;
    int trackspeed;
    int dmalen;
    unsigned int num_tracks, write_num_tracks, num_secs;
    unsigned int hard_num_cyls;
    int dskchange;
    int dskchange_time;
    int dskready;
    int dskready_time;
    int dskready_down_time;
    int steplimit;
    frame_time_t steplimitcycle;
    int indexhack, indexhackmode;
    int ddhd; /* 1=DD 2=HD */
    int drive_id_scnt; /* drive id shift counter */
    int idbit;
    unsigned long drive_id; /* drive id to be reported */
    char newname[256]; /* storage space for new filename during eject delay */
    uae_u32 crc32;
#ifdef FDI2RAW
    FDI *fdi;
#endif
    int useturbo;
    int floppybitcounter; /* number of bits left */
#ifdef CATWEASEL
    catweasel_drive *catweasel;
#else
    int catweasel;
#endif
} drive;

int disk_debug_logging;
int disk_debug_mode;
int disk_debug_track = -1;

#define MIN_STEPLIMIT_CYCLE (CYCLE_UNIT * 150)

static uae_u16 bigmfmbufw[0x4000 * DDHDMULT];

#ifndef SAVE_MEMORY
static drive floppy[MAX_FLOPPY_DRIVES];
#else
static drive *floppy;
#endif

#define MAX_PREVIOUS_FLOPPIES 99

#ifndef MAX_DPATH
#define MAX_DPATH 256
#endif

static char dfxhistory[MAX_PREVIOUS_FLOPPIES][MAX_DPATH];

static uae_u8 exeheader[]={0x00,0x00,0x03,0xf3,0x00,0x00,0x00,0x00};
static uae_u8 bootblock[]={
    0x44,0x4f,0x53,0x00,0xc0,0x20,0x0f,0x19,0x00,0x00,0x03,0x70,0x43,0xfa,0x00,0x18,
    0x4e,0xae,0xff,0xa0,0x4a,0x80,0x67,0x0a,0x20,0x40,0x20,0x68,0x00,0x16,0x70,0x00,
    0x4e,0x75,0x70,0xff,0x60,0xfa,0x64,0x6f,0x73,0x2e,0x6c,0x69,0x62,0x72,0x61,0x72,
    0x79
};

#define FS_OFS_DATABLOCKSIZE 488
#define FS_FLOPPY_BLOCKSIZE 512
#define FS_EXTENSION_BLOCKS 72
#define FS_FLOPPY_TOTALBLOCKS 1760
#define FS_FLOPPY_RESERVED 2

static void writeimageblock (struct zfile *dst, uae_u8 *sector, int offset)
{
    zfile_fseek (dst, offset, SEEK_SET);
    zfile_fwrite (sector, FS_FLOPPY_BLOCKSIZE, 1, dst);
}

static void disk_checksum (const uae_u8 *p, uae_u8 *c)
{
    uae_u32 cs = 0;
    int i;
    for (i = 0; i < FS_FLOPPY_BLOCKSIZE; i+= 4)
	cs += (p[i] << 24) | (p[i+1] << 16) | (p[i+2] << 8) | (p[i+3] << 0);
    cs = -cs;
    c[0] = cs >> 24; c[1] = cs >> 16; c[2] = cs >> 8; c[3] = cs >> 0;
}

static int dirhash (const char *name)
{
    unsigned long hash;
    unsigned int i;

    hash = strlen (name);
    for (i = 0; i < strlen (name); i++) {
	hash = hash * 13;
	hash = hash + toupper (name[i]);
	hash = hash & 0x7ff;
    }
    hash = hash % ((FS_FLOPPY_BLOCKSIZE / 4) - 56);
    return hash;
}

static void disk_date (uae_u8 *p)
{
    time_t t;
    struct tm *today;
    int year, days, minutes, ticks;
    char tmp[10];
    time (&t);
    today = localtime (&t);
    strftime (tmp, sizeof (tmp), "%Y", today);
    year = atol (tmp);
    strftime (tmp, sizeof (tmp), "%j", today);
    days = atol (tmp) - 1;
    strftime (tmp, sizeof (tmp), "%H", today);
    minutes = atol (tmp) * 60;
    strftime (tmp, sizeof (tmp), "%M", today);
    minutes += atol (tmp);
    strftime (tmp, sizeof (tmp), "%S", today);
    ticks = atol (tmp) * 50;
    while (year > 1978) {
	if ( !(year % 100) ? !(year % 400) : !(year % 4) ) days++;
	days += 365;
	year--;
    }
    p[0] = days >> 24; p[1] = days >> 16; p[2] = days >> 8; p[3] = days >> 0;
    p[4] = minutes >> 24; p[5] = minutes >> 16; p[6] = minutes >> 8; p[7] = minutes >> 0;
    p[8] = ticks >> 24; p[9] = ticks >> 16; p[10] = ticks >> 8; p[11] = ticks >> 0;
}

static void createbootblock (uae_u8 *sector, int bootable)
{
    memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
    memcpy (sector, "DOS", 3);
    if (bootable)
	memcpy (sector, bootblock, sizeof (bootblock));
}

static void createrootblock (uae_u8 *sector, const char *disk_name)
{
    memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
    sector[0+3] = 2;
    sector[12+3] = 0x48;
    sector[312] = sector[313] = sector[314] = sector[315] = (uae_u8)0xff;
    sector[316+2] = 881 >> 8; sector[316+3] = 881 & 255;
    sector[432] = strlen (disk_name);
    strcpy ((char *)sector + 433, disk_name);
    sector[508 + 3] = 1;
    disk_date (sector + 420);
    memcpy (sector + 472, sector + 420, 3 * 4);
    memcpy (sector + 484, sector + 420, 3 * 4);
}

static int getblock (uae_u8 *bitmap)
{
    int i = 0;
    while (bitmap[i] != 0xff) {
	if (bitmap[i] == 0) {
	    bitmap[i] = 1;
	    return i;
	}
	i++;
    }
    return -1;
}

static void pl (uae_u8 *sector, int offset, uae_u32 v)
{
    sector[offset + 0] = v >> 24;
    sector[offset + 1] = v >> 16;
    sector[offset + 2] = v >> 8;
    sector[offset + 3] = v >> 0;
}

static int createdirheaderblock (uae_u8 *sector, int parent, const char *filename, uae_u8 *bitmap)
{
    int block = getblock (bitmap);

    memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
    pl (sector, 0, 2);
    pl (sector, 4, block);
    disk_date (sector + 512 - 92);
    sector[512 - 80] = strlen (filename);
    strcpy ((char *)sector + 512 - 79, filename);
    pl (sector, 512 - 12, parent);
    pl (sector, 512 - 4, 2);
    return block;
}

static int createfileheaderblock (struct zfile *z,uae_u8 *sector, int parent, const char *filename, struct zfile *src, uae_u8 *bitmap)
{
    uae_u8 sector2[FS_FLOPPY_BLOCKSIZE];
    uae_u8 sector3[FS_FLOPPY_BLOCKSIZE];
    int block = getblock (bitmap);
    int datablock = getblock (bitmap);
    int datasec = 1;
    int extensions;
    int extensionblock, extensioncounter;
    int size;

    zfile_fseek (src, 0, SEEK_END);
    size = zfile_ftell (src);
    zfile_fseek (src, 0, SEEK_SET);
    extensions = (size + FS_OFS_DATABLOCKSIZE - 1) / FS_OFS_DATABLOCKSIZE;

    memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
    pl (sector, 0, 2);
    pl (sector, 4, block);
    pl (sector, 8, extensions > FS_EXTENSION_BLOCKS ? FS_EXTENSION_BLOCKS : extensions);
    pl (sector, 16, datablock);
    pl (sector, FS_FLOPPY_BLOCKSIZE - 188, size);
    disk_date (sector + FS_FLOPPY_BLOCKSIZE - 92);
    sector[FS_FLOPPY_BLOCKSIZE - 80] = strlen (filename);
    strcpy ((char *)(sector + FS_FLOPPY_BLOCKSIZE - 79), filename);
    pl (sector, FS_FLOPPY_BLOCKSIZE - 12, parent);
    pl (sector, FS_FLOPPY_BLOCKSIZE - 4, -3);
    extensioncounter = 0;
    extensionblock = 0;

    while (size > 0) {
	int datablock2 = datablock;
	int extensionblock2 = extensionblock;
	if (extensioncounter == FS_EXTENSION_BLOCKS) {
	    extensioncounter = 0;
	    extensionblock = getblock (bitmap);
	    if (datasec > FS_EXTENSION_BLOCKS + 1) {
		pl (sector3, 8, FS_EXTENSION_BLOCKS);
		pl (sector3, FS_FLOPPY_BLOCKSIZE - 8, extensionblock);
		pl (sector3, 4, extensionblock2);
		disk_checksum (sector3, sector3 + 20);
		writeimageblock (z, sector3, extensionblock2 * FS_FLOPPY_BLOCKSIZE);
	    } else {
		pl (sector, 512 - 8, extensionblock);
	    }
	    memset (sector3, 0, FS_FLOPPY_BLOCKSIZE);
	    pl (sector3, 0, 16);
	    pl (sector3, FS_FLOPPY_BLOCKSIZE - 12, block);
	    pl (sector3, FS_FLOPPY_BLOCKSIZE - 4, -3);
	}
	memset (sector2, 0, FS_FLOPPY_BLOCKSIZE);
	pl (sector2, 0, 8);
	pl (sector2, 4, block);
	pl (sector2, 8, datasec++);
	pl (sector2, 12, size > FS_OFS_DATABLOCKSIZE ? FS_OFS_DATABLOCKSIZE : size);
	zfile_fread (sector2 + 24, size > FS_OFS_DATABLOCKSIZE ? FS_OFS_DATABLOCKSIZE : size, 1, src);
	size -= FS_OFS_DATABLOCKSIZE;
	datablock = 0;
	if (size > 0) datablock = getblock (bitmap);
	pl (sector2, 16, datablock);
	disk_checksum (sector2, sector2 + 20);
	writeimageblock (z, sector2, datablock2 * FS_FLOPPY_BLOCKSIZE);
	if (datasec <= FS_EXTENSION_BLOCKS + 1)
	    pl (sector, 512 - 204 - extensioncounter * 4, datablock2);
	else
	    pl (sector3, 512 - 204 - extensioncounter * 4, datablock2);
	extensioncounter++;
    }
    if (datasec > FS_EXTENSION_BLOCKS) {
	pl (sector3, 8, extensioncounter);
	disk_checksum (sector3, sector3 + 20);
	writeimageblock (z, sector3, extensionblock * FS_FLOPPY_BLOCKSIZE);
    }
    disk_checksum (sector, sector + 20);
    writeimageblock (z, sector, block * FS_FLOPPY_BLOCKSIZE);
    return block;
}

static void createbitmapblock (uae_u8 *sector, uae_u8 *bitmap)
{
    uae_u8 mask;
    int i, j;
    memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
    for (i = FS_FLOPPY_RESERVED; i < FS_FLOPPY_TOTALBLOCKS; i += 8) {
	mask = 0;
	for (j = 0; j < 8; j++) {
	    if (bitmap[i + j]) mask |= 1 << j;
	}
	sector[4 + i / 8] = mask;
    }
    disk_checksum (sector, sector + 0);
}

static int createimagefromexe (struct zfile *src, struct zfile *dst)
{
    uae_u8 sector1[FS_FLOPPY_BLOCKSIZE], sector2[FS_FLOPPY_BLOCKSIZE];
    uae_u8 bitmap[FS_FLOPPY_TOTALBLOCKS + 8];
    int exesize;
    int blocksize = FS_OFS_DATABLOCKSIZE;
    int blocks, extensionblocks;
    int totalblocks;
    int fblock1, dblock1;
    const char *fname1 = "runme.exe";
    const char *fname2 = "startup-sequence";
    const char *dirname1 = "s";
    struct zfile *ss;

    memset (bitmap, 0, sizeof (bitmap));
    zfile_fseek (src, 0, SEEK_END);
    exesize = zfile_ftell (src);
    blocks = (exesize + blocksize - 1) / blocksize;
    extensionblocks = (blocks + FS_EXTENSION_BLOCKS - 1) / FS_EXTENSION_BLOCKS;
    /* bootblock=2, root=1, bitmap=1, startup-sequence=1+1, exefileheader=1 */
    totalblocks = 2 + 1 + 1 + 2 + 1 + blocks + extensionblocks;
    if (totalblocks > FS_FLOPPY_TOTALBLOCKS)
	return 0;

    bitmap[880] = 1;
    bitmap[881] = 1;
    bitmap[0] = 1;
    bitmap[1] = 1;

    dblock1 = createdirheaderblock (sector2, 880, dirname1, bitmap);
    ss = zfile_fopen_empty (fname1, strlen (fname1));
    zfile_fwrite (fname1, strlen (fname1), 1, ss);
    fblock1 = createfileheaderblock (dst, sector1,  dblock1, fname2, ss, bitmap);
    zfile_fclose (ss);
    pl (sector2, 24 + dirhash (fname2) * 4, fblock1);
    disk_checksum (sector2, sector2 + 20);
    writeimageblock (dst, sector2, dblock1 * FS_FLOPPY_BLOCKSIZE);

    fblock1 = createfileheaderblock (dst, sector1, 880, fname1, src, bitmap);

    createrootblock (sector1, "empty");
    pl (sector1, 24 + dirhash (fname1) * 4, fblock1);
    pl (sector1, 24 + dirhash (dirname1) * 4, dblock1);
    disk_checksum (sector1, sector1 + 20);
    writeimageblock (dst, sector1, 880 * FS_FLOPPY_BLOCKSIZE);

    createbitmapblock (sector1, bitmap);
    writeimageblock (dst, sector1, 881 * FS_FLOPPY_BLOCKSIZE);

    createbootblock (sector1, 1);
    writeimageblock (dst, sector1, 0 * FS_FLOPPY_BLOCKSIZE);

    return 1;
}

static int get_floppy_speed (void)
{
    int m = currprefs.floppy_speed;
    if (m <= 10)
	m = 100;
    m = NORMAL_FLOPPY_SPEED * 100 / m;
    return m;
}

#ifdef DEBUG_DRIVE_ID
static const char *drive_id_name (drive *drv)
    {
    switch (drv->drive_id) {
    case DRIVE_ID_35HD : return "3.5HD";
    case DRIVE_ID_525SD: return "5.25SD";
    case DRIVE_ID_35DD : return "3.5DD";
    }
    return "UNKNOWN";
}
#endif

/* Simulate exact behaviour of an A3000T 3.5 HD disk drive.
 * The drive reports to be a 3.5 DD drive whenever there is no
 * disk or a 3.5 DD disk is inserted. Only 3.5 HD drive id is reported
 * when a real 3.5 HD disk is inserted. -Adil
 */
static void drive_settype_id (drive *drv)
{
    int t = currprefs.dfxtype[drv - &floppy[0]];

    switch (t)
    {
	case DRV_35_HD:
#ifdef FLOPPY_DRIVE_HD
	if (!drv->diskfile || drv->ddhd <= 1)
	    drv->drive_id = DRIVE_ID_35DD;
	else
	    drv->drive_id = DRIVE_ID_35HD;
#else
	drv->drive_id = DRIVE_ID_35DD;
#endif
	break;
	case DRV_35_DD_ESCOM:
	case DRV_35_DD:
	default:
	drv->drive_id = DRIVE_ID_35DD;
	break;
	case DRV_525_SD:
	drv->drive_id = DRIVE_ID_525SD;
	break;
    }
#ifdef DEBUG_DRIVE_ID
    write_log ("drive_settype_id: DF%d: set to %s\n", drv-floppy, drive_id_name (drv));
#endif
}

static void drive_image_free (drive *drv)
{
    switch (drv->filetype)
    {
	case ADF_IPF:
#ifdef CAPS
	caps_unloadimage (drv - floppy);
#endif
	break;
	case ADF_FDI:
#ifdef FDI2RAW
	fdi2raw_header_free (drv->fdi);
	drv->fdi = 0;
#endif
	break;
	default:
	    break;
    }
    drv->filetype = -1;
    zfile_fclose (drv->diskfile);
    drv->diskfile = 0;
    zfile_fclose (drv->writediskfile);
    drv->writediskfile = 0;
}

static int drive_insert (drive * drv, struct uae_prefs *p, int dnum, const char *fname);

static void reset_drive (int i)
{
    drive *drv = &floppy[i];
    drive_image_free (drv);
    drv->motoroff = 1;
    disabled &= ~(1 << i);
    gui_data.drive_disabled[i] = 0;
    gui_data.df[i][0] = 0;
    gui_data.crc32[i] = 0;
    if (currprefs.dfxtype[i] < 0) {
	disabled |= 1 << i;
	gui_data.drive_disabled[i] = 1;
    }
    /* most internal Amiga floppy drives won't enable
     * diskready until motor is running at full speed
     * and next indexsync has been passed
     */
    drv->indexhackmode = 0;
    if (i == 0 && currprefs.dfxtype[i] == 0)
	drv->indexhackmode = 1;
    drv->dskchange_time = 0;
    drv->buffered_cyl = -1;
    drv->buffered_side = -1;
    gui_led (i + 1, 0);
    drive_settype_id (drv);
    strcpy (currprefs.df[i], changed_prefs.df[i]);
    drv->newname[0] = 0;
    if (!drive_insert (drv, &currprefs, i, currprefs.df[i]))
	disk_eject (i);
}

/* code for track display */
static void update_drive_gui (int num)
{
    drive *drv = floppy + num;
    int writ = dskdmaen == 3 && drv->state && !(selected & (1 << num));

    if (drv->state == gui_data.drive_motor[num]
	&& drv->cyl == gui_data.drive_track[num]
	&& side == gui_data.drive_side
	&& drv->crc32 == gui_data.crc32[num]
	&& writ == gui_data.drive_writing[num])
	return;
    strcpy (gui_data.df[num], currprefs.df[num]);
    gui_data.crc32[num] = drv->crc32;
    gui_data.drive_motor[num] = drv->state;
    gui_data.drive_track[num] = drv->cyl;
    gui_data.drive_side = side;
    gui_data.drive_writing[num] = writ;
    gui_ledstate &= ~(2 << num);
    if (drv->state)
	gui_ledstate |= 2 << num;
    gui_led (num + 1, gui_data.drive_motor[num]);
}

static void drive_fill_bigbuf (drive * drv,int);

struct zfile *DISK_validate_filename (const char *fname, int leave_open, int *wrprot, uae_u32 *crc32)
{
    if (crc32)
	*crc32 = 0;
    if (leave_open) {
	struct zfile *f = zfile_fopen (fname, "r+b");
	if (f) {
	    if (wrprot)
		*wrprot = 0;
	} else {
	    if (wrprot)
		*wrprot = 1;
	    f = zfile_fopen (fname, "rb");
	}
	if (f && crc32)
	    *crc32 = zfile_crc32 (f);
	return f;
    } else {
	if (zfile_exists (fname)) {
	    if (wrprot)
		*wrprot = 0;
	    if (crc32) {
		struct zfile *f = zfile_fopen (fname, "rb");
		if (f)
		    *crc32 = zfile_crc32 (f);
		zfile_fclose (f);
	    }
	    return (void*)1;
	} else {
	    if (wrprot)
		*wrprot = 1;
	    return 0;
	}
    }
}

static void updatemfmpos (drive *drv)
{
    if (drv->prevtracklen)
	drv->mfmpos = drv->mfmpos * (drv->tracklen * 1000 / drv->prevtracklen) / 1000;
    drv->mfmpos %= drv->tracklen;
    drv->prevtracklen = drv->tracklen;
}

static void track_reset (drive *drv)
{
    drv->tracklen = FLOPPY_WRITE_LEN * drv->ddhd * 2 * 8;
    drv->trackspeed = get_floppy_speed ();
    drv->buffered_side = -1;
    drv->skipoffset = -1;
    drv->tracktiming[0] = 0;
    memset (drv->bigmfmbuf, 0xaa, FLOPPY_WRITE_LEN * 2 * drv->ddhd);
    updatemfmpos (drv);
}

static unsigned int read_header_ext2 (struct zfile *diskfile, trackid *trackdata, unsigned int *num_tracks, int *ddhd)
{
    uae_u8 buffer[2 + 2 + 4 + 4];
    trackid *tid;
    unsigned int offs;
    unsigned int i;

    zfile_fseek (diskfile, 0, SEEK_SET);
    zfile_fread (buffer, 1, 8, diskfile);
    if (strncmp ((char*)buffer, "UAE-1ADF", 8))
	return 0;
    zfile_fread (buffer, 1, 4, diskfile);
    *num_tracks = buffer[2] * 256 + buffer[3];
    offs = 8 + 2 + 2 + (*num_tracks) * (2 + 2 + 4 + 4);

    for (i = 0; i < (*num_tracks); i++) {
	tid = trackdata + i;
	zfile_fread (buffer, 2 + 2 + 4 + 4, 1, diskfile);
	tid->type = buffer[2] * 256 + buffer[3];
	tid->len = buffer[5] * 65536 + buffer[6] * 256 + buffer[7];
	tid->bitlen = buffer[9] * 65536 + buffer[10] * 256 + buffer[11];
	tid->offs = offs;
	if (tid->len > 20000 && ddhd)
	    *ddhd = 2;
	tid->track = i;
	offs += tid->len;
    }
    return 1;
}

char *DISK_get_saveimagepath (const char *name)
{
    static char name1[MAX_DPATH];
    char name2[MAX_DPATH];
    int i;

    strcpy (name2, name);
    i = strlen (name2) - 1;
    while (i > 0) {
	if (name2[i] == '.') {
	    name2[i] = 0;
	    break;
	}
	i--;
    }
    while (i > 0) {
	if (name2[i] == '/' || name2[i] == '\\'
#ifdef TARGET_AMIGAOS
	    || name2[i] == ':'
#endif
	    ) {
	    i++;
	    break;
	}
	i--;
    }

    sprintf (name1, "%s%s_save.adf", prefs_get_attr ("floppy_path"), name2 + i);

    return name1;
}

static struct zfile *getwritefile (const char *name, int *wrprot)
{
    return DISK_validate_filename (DISK_get_saveimagepath (name), 1, wrprot, NULL);
}

static int iswritefileempty (const char *name)
{
    struct zfile *zf;
    int wrprot;
    uae_u8 buffer[8];
    trackid td[MAX_TRACKS];
    unsigned int tracks, i, ret;
    int ddhd;

    zf = getwritefile (name, &wrprot);
    if (!zf) return 1;
    zfile_fread (buffer, sizeof (char), 8, zf);
    if (strncmp ((char *) buffer, "UAE-1ADF", 8))
	return 0;
    ret = read_header_ext2 (zf, td, &tracks, &ddhd);
    zfile_fclose (zf);
    if (!ret)
	return 1;
    for (i = 0; i < tracks; i++) {
	if (td[i].bitlen) return 0;
    }
    return 1;
}

static int openwritefile (drive *drv, int create)
{
    int wrprot = 0;

    drv->writediskfile = getwritefile (currprefs.df[drv - &floppy[0]], &wrprot);
    if (drv->writediskfile) {
	drv->wrprot = wrprot;
	if (!read_header_ext2 (drv->writediskfile, drv->writetrackdata, &drv->write_num_tracks, 0)) {
	    zfile_fclose (drv->writediskfile);
	    drv->writediskfile = 0;
	    drv->wrprot = 1;
	} else {
	    if (drv->write_num_tracks > drv->num_tracks)
		drv->num_tracks = drv->write_num_tracks;
	}
    } else if (zfile_iscompressed (drv->diskfile)) {
	drv->wrprot = 1;
    }
    return drv->writediskfile ? 1 : 0;
}

static int diskfile_iswriteprotect (const char *fname, int *needwritefile, drive_type *drvtype)
{
    struct zfile *zf1, *zf2;
    int wrprot1 = 0, wrprot2 = 1;
    unsigned char buffer[25];

    *needwritefile = 0;
    *drvtype = DRV_35_DD;
    zf1 = DISK_validate_filename (fname, 1, &wrprot1, NULL);
    if (!zf1)
	return 1;
    if (zfile_iscompressed (zf1)) {
	wrprot1 = 1;
	*needwritefile = 1;
    }

    zf2 = getwritefile (fname, &wrprot2);
    zfile_fclose (zf2);
    zfile_fread (buffer, sizeof (char), 25, zf1);
    zfile_fclose (zf1);

    if (strncmp ((char *) buffer, "CAPS", 4) == 0) {
	*needwritefile = 1;
	return wrprot2;
    }
    if (strncmp ((char *) buffer, "Formatted Disk Image file", 25) == 0) {
	*needwritefile = 1;
	return wrprot2;
    }
    if (strncmp ((char *) buffer, "UAE-1ADF", 8) == 0) {
	if (wrprot1)
	    return wrprot2;
	return wrprot1;
    }
    if (strncmp ((char *) buffer, "UAE--ADF", 8) == 0) {
	*needwritefile = 1;
	return wrprot2;
    }
    if (memcmp (exeheader, buffer, sizeof (exeheader)) == 0)
	return 0;
    if (wrprot1)
	return wrprot2;
    return wrprot1;
}

static int drive_insert (drive * drv, struct uae_prefs *p, int dnum, const char *fname)
{
    unsigned char buffer[2 + 2 + 4 + 4];
    trackid *tid;
    int size;

    drive_image_free (drv);
    drv->diskfile = DISK_validate_filename (fname, 1, &drv->wrprot, &drv->crc32);
    drv->ddhd = 1;
    drv->num_secs = 0;
    drv->hard_num_cyls = p->dfxtype[dnum] == DRV_525_SD ? 40 : 80;
    drv->tracktiming[0] = 0;
    drv->useturbo = 0;
    drv->indexoffset = 0;

    if (!drv->motoroff) {
	drv->dskready_time = DSKREADY_TIME;
	drv->dskready_down_time = 0;
    }

    if (drv->diskfile == 0 && !drv->catweasel) {
	track_reset (drv);
	return 0;
    }
    strncpy (currprefs.df[dnum], fname, 255);
    currprefs.df[dnum][255] = 0;
    strncpy (changed_prefs.df[dnum], fname, 255);
    changed_prefs.df[dnum][255] = 0;
    strcpy (drv->newname, fname);
    gui_filename (dnum, fname);

    memset (buffer, 0, sizeof (buffer));
    size = 0;
    if (drv->diskfile) {
	zfile_fread (buffer, sizeof (char), 8, drv->diskfile);
	zfile_fseek (drv->diskfile, 0, SEEK_END);
	size = zfile_ftell (drv->diskfile);
	zfile_fseek (drv->diskfile, 0, SEEK_SET);
    }


    if (drv->catweasel) {

	drv->wrprot = 1;
	drv->filetype = ADF_CATWEASEL;
	drv->num_tracks = 80;
	drv->ddhd = 1;

#ifdef CAPS
    } else if (strncmp ((char *) buffer, "CAPS", 4) == 0) {

	unsigned int num_tracks;

	drv->wrprot = 1;
	if (!caps_loadimage (drv->diskfile, drv - floppy, &num_tracks)) {
	    zfile_fclose (drv->diskfile);
	    drv->diskfile = 0;
	    return 0;
	}
	drv->num_tracks = num_tracks;
	drv->filetype = ADF_IPF;
#endif
#ifdef FDI2RAW
    } else if ((drv->fdi = fdi2raw_header (drv->diskfile))) {

	drv->wrprot = 1;
	drv->num_tracks = fdi2raw_get_last_track (drv->fdi);
	drv->num_secs = fdi2raw_get_num_sector (drv->fdi);
	drv->filetype = ADF_FDI;
#endif
    } else if (strncmp ((char *) buffer, "UAE-1ADF", 8) == 0) {

	read_header_ext2 (drv->diskfile, drv->trackdata, &drv->num_tracks, &drv->ddhd);
	drv->filetype = ADF_EXT2;
	drv->num_secs = 11;
	if (drv->ddhd > 1)
	    drv->num_secs = 22;

    } else if (strncmp ((char *) buffer, "UAE--ADF", 8) == 0) {
	int offs = 160 * 4 + 8;
	int i;

	drv->wrprot = 1;
	drv->filetype = ADF_EXT1;
	drv->num_tracks = 160;
	drv->num_secs = 11;

	zfile_fseek (drv->diskfile, 8, SEEK_SET);
	for (i = 0; i < 160; i++) {
	    tid = &drv->trackdata[i];
	    zfile_fread (buffer, 4, 1, drv->diskfile);
	    tid->sync = buffer[0] * 256 + buffer[1];
	    tid->len = buffer[2] * 256 + buffer[3];
	    tid->offs = offs;
	    if (tid->sync == 0) {
		tid->type = TRACK_AMIGADOS;
		tid->bitlen = 0;
	    } else {
		tid->type = TRACK_RAW1;
		tid->bitlen = tid->len * 8;
	    }
	    offs += tid->len;
	}

    } else if (memcmp (exeheader, buffer, sizeof (exeheader)) == 0) {

	unsigned int i;
	struct zfile *z = zfile_fopen_empty ("", 512 * 1760);
	createimagefromexe (drv->diskfile, z);
	drv->filetype = ADF_NORMAL;
	zfile_fclose (drv->diskfile);
	drv->diskfile = z;
	drv->num_tracks = 160;
	drv->num_secs = 11;
	for (i = 0; i < drv->num_tracks; i++) {
	    tid = &drv->trackdata[i];
	    tid->type = TRACK_AMIGADOS;
	    tid->len = 512 * drv->num_secs;
	    tid->bitlen = 0;
	    tid->offs = i * 512 * drv->num_secs;
	}
	drv->useturbo = 1;

    } else if (size == 720 * 1024 || size == 1440 * 1024) {
	/* PC formatted image */
	unsigned int i;

	drv->filetype = ADF_PCDOS;
	drv->num_tracks = 160;
	drv->ddhd = size == 1440 * 1024 ? 2 : 1;
	drv->num_secs = drv->ddhd == 2 ? 18 : 9;
	for (i = 0; i < drv->num_tracks; i++) {
	    tid = &drv->trackdata[i];
	    tid->type = TRACK_PCDOS;
	    tid->len = 512 * drv->num_secs;
	    tid->bitlen = 0;
	    tid->offs = i * 512 * drv->num_secs;
	}

    } else {
	unsigned int i;

	drv->filetype = ADF_NORMAL;

	/* High-density disk? */
	if (size >= 160 * 22 * 512) {
	    drv->num_tracks = size / (512 * (drv->num_secs = 22));
	    drv->ddhd = 2;
	} else
	    drv->num_tracks = size / (512 * (drv->num_secs = 11));

	if (drv->num_tracks > MAX_TRACKS)
	    write_log ("Your diskfile is too big!\n");
	for (i = 0; i < drv->num_tracks; i++) {
	    tid = &drv->trackdata[i];
	    tid->type = TRACK_AMIGADOS;
	    tid->len = 512 * drv->num_secs;
	    tid->bitlen = 0;
	    tid->offs = i * 512 * drv->num_secs;
	}
    }

    openwritefile (drv, 0);

    drive_settype_id (drv); /* Set DD or HD drive */
    drive_fill_bigbuf (drv, 1);
    drv->mfmpos = (rand () | (rand () << 16)) % drv->tracklen;
    drv->prevtracklen = 0;
#ifdef DRIVESOUND
    driveclick_insert (drv - floppy, 0);
#endif
    return 1;
}

static void rand_shifter (void)
{
    unsigned int r = ((rand () >> 4) & 7) + 1;
    while (r-- > 0) {
	word <<= 1;
	word |= (rand () & 0x1000) ? 1 : 0;
	bitoffset++;
	bitoffset &= 15;
    }
}

static int drive_empty (drive * drv)
{
#ifdef CATWEASEL
    if (drv->catweasel)
	return catweasel_disk_changed (drv->catweasel) == 0;
#endif
    return drv->diskfile == 0;
}

static void drive_step (drive * drv)
{
#if 0
    if (drv->dskready) {
	drv->dskready = 0;
	drv->dskready_time = DSKREADY_TIME;
    }
#endif
#ifdef CATWEASEL
    if (drv->catweasel) {
	int dir = direction ? -1 : 1;
	catweasel_step (drv->catweasel, dir);
	drv->cyl += dir;
	if (drv->cyl < 0)
	    drv->cyl = 0;
	write_log ("%d -> %d\n", dir, drv->cyl);
	return;
    }
#endif
    if (drv->steplimit && get_cycles () - drv->steplimitcycle < MIN_STEPLIMIT_CYCLE) {
	if (disk_debug_logging > 1)
    	    write_log (" step ignored %d", (int)((get_cycles () - drv->steplimitcycle) / CYCLE_UNIT));
	return;
    }
    /* A1200's floppy drive needs at least 30 raster lines between steps
     * but we'll use very small value for better compatibility with faster CPU emulation
     * (stupid trackloaders with CPU delay loops)
     */
    drv->steplimit = 10;
    drv->steplimitcycle = get_cycles ();
    if (!drive_empty (drv))
	drv->dskchange = 0;
    if (direction) {
	if (drv->cyl) {
	    drv->cyl--;
#ifdef DRIVESOUND
	    driveclick_click (drv - floppy, drv->cyl);
#endif
	}
/*	else
	    write_log("program tried to step beyond track zero\n");
	    "no-click" programs does that
*/
  } else {
	unsigned int maxtrack = drv->hard_num_cyls;
	if (drv->cyl < maxtrack + 3) {
	    drv->cyl++;
#ifdef CATWEASEL
	    if (drv->catweasel)
		catweasel_step (drv->catweasel, 1);
#endif
	}
	if (drv->cyl >= maxtrack)
	    write_log ("program tried to step over track %d\n", maxtrack);
#ifdef DRIVESOUND
	driveclick_click (drv - floppy, drv->cyl);
#endif
    }
    rand_shifter ();
    if (disk_debug_logging > 1)
        write_log (" ->step %d", drv->cyl);
}

static int drive_track0 (drive * drv)
{
#ifdef CATWEASEL
    if (drv->catweasel)
	return catweasel_track0 (drv->catweasel);
#endif
    return drv->cyl == 0;
}

static int drive_writeprotected (drive * drv)
{
#ifdef CATWEASEL
    if (drv->catweasel)
	return 1;
#endif
    return drv->wrprot || drv->diskfile == NULL;
}

static int drive_running (drive * drv)
{
    return !drv->motoroff;
}

static void drive_motor (drive * drv, int off)
{
    if (drv->motoroff && !off) {
	drv->dskready_time = DSKREADY_TIME;
	rand_shifter ();
#ifdef DRIVESOUND
	driveclick_motor (drv - floppy, drv->dskready_down_time == 0 ? 2 : 1);
#endif
	if (disk_debug_logging > 1)
	    write_log (" ->motor on");
    }
    if (!drv->motoroff && off) {
	drv->drive_id_scnt = 0; /* Reset id shift reg counter */
	drv->dskready_down_time = DSKREADY_DOWN_TIME;
#ifdef DRIVESOUND
	driveclick_motor (drv - floppy, 0);
#endif
#ifdef DEBUG_DRIVE_ID
	write_log ("drive_motor: Selected DF%d: reset id shift reg.\n",drv-floppy);
#endif
	if (disk_debug_logging > 1)
	    write_log (" ->motor off");
	if (currprefs.cpu_level <= 1) {
	    drv->motordelay = 1;
	    diskevent_flag = DISK_MOTORDELAY;
	    eventtab[ev_disk].oldcycles = get_cycles ();
	    eventtab[ev_disk].evtime = get_cycles () + 30 * CYCLE_UNIT;
	    eventtab[ev_disk].active = 1;
	    events_schedule ();
	}
    }
    drv->motoroff = off;
    if (drv->motoroff) {
	drv->dskready = 0;
	drv->dskready_time = 0;
    }
#ifdef CATWEASEL
    if (drv->catweasel)
	catweasel_set_motor (drv->catweasel, !drv->motoroff);
#endif
}

static void read_floppy_data (struct zfile *diskfile, trackid *tid, int offset, void *dst, int len)
{
    if (len == 0)
	return;
    zfile_fseek (diskfile, tid->offs + offset, SEEK_SET);
    zfile_fread (dst, 1, len, diskfile);
}

/* Megalomania does not like zero MFM words... */
static void mfmcode (uae_u16 *mfm, unsigned int words)
{
    uae_u32 lastword = 0;
    while (words--) {
	uae_u32 v = *mfm;
	uae_u32 lv = (lastword << 16) | v;
	uae_u32 nlv = 0x55555555 & ~lv;
	uae_u32 mfmbits = (nlv << 1) & (nlv >> 1);
	*mfm++ = v | mfmbits;
	lastword = v;
    }
}

static uae_u8 mfmencodetable[16] = {
    0x2a, 0x29, 0x24, 0x25, 0x12, 0x11, 0x14, 0x15,
    0x4a, 0x49, 0x44, 0x45, 0x52, 0x51, 0x54, 0x55
};


static uae_u16 dos_encode_byte (uae_u8 byte)
{
    uae_u8 b2, b1;
    uae_u16 word;

    b1 = byte;
    b2 = b1 >> 4;
    b1 &= 15;
    word = mfmencodetable[b2] <<8 | mfmencodetable[b1];
    return (word | ((word & (256 | 64)) ? 0 : 128));
}

static uae_u16 *mfmcoder (uae_u8 *src, uae_u16 *dest, int len)
{
    int i;

    for (i = 0; i < len; i++) {
	*dest = dos_encode_byte (*src++);
	*dest |= ((dest[-1] & 1)||(*dest & 0x4000)) ? 0: 0x8000;
	dest++;
    }
    return dest;
}

static void decode_pcdos (drive *drv)
{
    unsigned int i;
    unsigned int tr = drv->cyl * 2 + side;
    uae_u16 *dstmfmbuf, *mfm2;
    uae_u8 secbuf[700];
    uae_u16 crc16;
    trackid *ti = drv->trackdata + tr;

    mfm2 = drv->bigmfmbuf;
    *mfm2++ = 0x9254;
    memset (secbuf, 0x4e, 80); // 94
    memset (secbuf + 80, 0x00, 12); // 12
    secbuf[92] = 0xc2;
    secbuf[93] = 0xc2;
    secbuf[94] = 0xc2;
    secbuf[95] = 0xfc;
    memset (secbuf + 96, 0x4e, 50); // 50
    dstmfmbuf = mfmcoder (secbuf, mfm2, 146);
    mfm2[92] = 0x5224;
    mfm2[93] = 0x5224;
    mfm2[94] = 0x5224;
    for (i = 0; i < drv->num_secs; i++) {
        mfm2 = dstmfmbuf;
	memset (secbuf, 0x00, 12);
	secbuf[12] = 0xa1;
	secbuf[13] = 0xa1;
	secbuf[14] = 0xa1;
	secbuf[15] = 0xfe;
	secbuf[16] = drv->cyl;
	secbuf[17] = side;
	secbuf[18] = 1 + i;
	secbuf[19] = 2; // 128 << 2 = 512
	crc16 = get_crc16 (secbuf + 12, 3 + 1 + 4);
	secbuf[20] = crc16 >> 8;
	secbuf[21] = crc16 & 0xff;
	memset (secbuf + 22, 0x4e, 22);
	memset (secbuf + 44, 0x00, 12);
	secbuf[56] = 0xa1;
	secbuf[57] = 0xa1;
	secbuf[58] = 0xa1;
	secbuf[59] = 0xfb;
	read_floppy_data (drv->diskfile, ti, i * 512, &secbuf[60], 512);
	crc16 = get_crc16(secbuf + 56, 3 + 1 + 512);
	secbuf[60 + 512] = crc16 >> 8;
	secbuf[61 + 512] = crc16 & 0xff;
	memset (secbuf + 512 + 62, 0x4e, 76 / drv->ddhd);
	dstmfmbuf = mfmcoder (secbuf, mfm2, 60 + 512 + 2 + 76 / drv->ddhd);
	mfm2[12] = 0x4489;
	mfm2[13] = 0x4489;
	mfm2[14] = 0x4489;
	mfm2[56] = 0x4489;
	mfm2[57] = 0x4489;
	mfm2[58] = 0x4489;
    }
    for (i = 0; i < 200; i++)
        *dstmfmbuf++ = 0x9254;
    drv->skipoffset = 0;
    drv->tracklen = (dstmfmbuf - drv->bigmfmbuf) * 16;
    if (disk_debug_logging > 0)
        write_log ("pcdos read track %d\n", tr);
}

static void decode_amigados (drive *drv)
{
    /* Normal AmigaDOS format track */
    unsigned int tr = drv->cyl * 2 + side;
    unsigned int sec;
    int dstmfmoffset = 0;
    uae_u16 *dstmfmbuf = drv->bigmfmbuf;
    int len = drv->num_secs * 544 + FLOPPY_GAP_LEN;

    trackid *ti = drv->trackdata + tr;
    memset (dstmfmbuf, 0xaa, len * 2);
    dstmfmoffset += FLOPPY_GAP_LEN;
    drv->skipoffset = (FLOPPY_GAP_LEN * 8) / 3 * 2;
    drv->tracklen = len * 2 * 8;

    for (sec = 0; sec < drv->num_secs; sec++) {
        uae_u8 secbuf[544];
        uae_u16 mfmbuf[544];
        int i;
        uae_u32 deven, dodd;
        uae_u32 hck = 0, dck = 0;

        secbuf[0] = secbuf[1] = 0x00;
        secbuf[2] = secbuf[3] = 0xa1;
        secbuf[4] = 0xff;
        secbuf[5] = tr;
        secbuf[6] = sec;
        secbuf[7] = drv->num_secs - sec;

        for (i = 8; i < 24; i++)
	    secbuf[i] = 0;

	read_floppy_data (drv->diskfile, ti, sec * 512, &secbuf[32], 512);

        mfmbuf[0] = mfmbuf[1] = 0xaaaa;
        mfmbuf[2] = mfmbuf[3] = 0x4489;

        deven = ((secbuf[4] << 24) | (secbuf[5] << 16)
		     | (secbuf[6] << 8) | (secbuf[7]));
        dodd = deven >> 1;
        deven &= 0x55555555;
        dodd &= 0x55555555;

        mfmbuf[4] = dodd >> 16;
        mfmbuf[5] = dodd;
        mfmbuf[6] = deven >> 16;
        mfmbuf[7] = deven;

        for (i = 8; i < 48; i++)
	    mfmbuf[i] = 0xaaaa;
	for (i = 0; i < 512; i += 4) {
	    deven = ((secbuf[i + 32] << 24) | (secbuf[i + 33] << 16)
			 | (secbuf[i + 34] << 8) | (secbuf[i + 35]));
	    dodd = deven >> 1;
	    deven &= 0x55555555;
	    dodd &= 0x55555555;
	    mfmbuf[(i >> 1) + 32] = dodd >> 16;
	    mfmbuf[(i >> 1) + 33] = dodd;
	    mfmbuf[(i >> 1) + 256 + 32] = deven >> 16;
	    mfmbuf[(i >> 1) + 256 + 33] = deven;
	}

	for (i = 4; i < 24; i += 2)
	    hck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];

        deven = dodd = hck;
        dodd >>= 1;
        mfmbuf[24] = dodd >> 16;
        mfmbuf[25] = dodd;
        mfmbuf[26] = deven >> 16;
        mfmbuf[27] = deven;

        for (i = 32; i < 544; i += 2)
	    dck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];

        deven = dodd = dck;
        dodd >>= 1;
        mfmbuf[28] = dodd >> 16;
        mfmbuf[29] = dodd;
        mfmbuf[30] = deven >> 16;
        mfmbuf[31] = deven;
        mfmcode (mfmbuf + 4, 544 - 4);

        for (i = 0; i < 544; i++) {
	    dstmfmbuf[dstmfmoffset % len] = mfmbuf[i];
	    dstmfmoffset++;
	}
     }

    if (disk_debug_logging > 0)
        write_log ("amigados read track %d\n", tr);
}

static void drive_fill_bigbuf (drive * drv, int force)
{
    unsigned int tr = drv->cyl * 2 + side;
    trackid *ti = drv->trackdata + tr;

    if ((!drv->diskfile && !drv->catweasel) || tr >= drv->num_tracks) {
	track_reset (drv);
	return;
    }

    if (!force && drv->catweasel) {
	drv->buffered_cyl = -1;
	return;
    }

    if (!force && drv->buffered_cyl == (int)drv->cyl && drv->buffered_side == side)
	return;
    drv->indexoffset = 0;
    drv->multi_revolution = 0;
    drv->tracktiming[0] = 0;
    drv->skipoffset = -1;

    if (drv->writediskfile && drv->writetrackdata[tr].bitlen > 0) {
	unsigned int i;
	trackid *wti = &drv->writetrackdata[tr];
	drv->tracklen = wti->bitlen;
	read_floppy_data (drv->writediskfile, wti, 0, drv->bigmfmbuf, (wti->bitlen + 7) / 8);
	for (i = 0; i < (drv->tracklen + 15) / 16; i++) {
	    uae_u16 *mfm = drv->bigmfmbuf + i;
	    uae_u8 *data = (uae_u8 *) mfm;
	    *mfm = 256 * *data + *(data + 1);
	}
	if (disk_debug_logging > 0)
	    write_log ("track %d, length %d read from \"saveimage\"\n", tr, drv->tracklen);
    } else if (drv->filetype == ADF_CATWEASEL) {
#ifdef CATWEASEL
	drv->tracklen = 0;
	if (!catweasel_disk_changed (drv->catweasel)) {
	    drv->tracklen = catweasel_fillmfm (drv->catweasel, drv->bigmfmbuf, side, drv->ddhd, 0);
	}
	drv->buffered_cyl = -1;
	if (!drv->tracklen) {
	    track_reset (drv);
	    return;
	}
#endif
    } else if (drv->filetype == ADF_IPF) {

#ifdef CAPS
	caps_loadtrack (drv->bigmfmbuf, drv->tracktiming, drv - floppy, tr, &drv->tracklen, &drv->multi_revolution, &drv->skipoffset);
#endif

    } else if (drv->filetype == ADF_FDI) {

#ifdef FDI2RAW
	fdi2raw_loadtrack (drv->fdi, drv->bigmfmbuf, drv->tracktiming, tr, &drv->tracklen, &drv->indexoffset, &drv->multi_revolution, 1);
#endif

    } else if (ti->type == TRACK_PCDOS) {

	decode_pcdos (drv);

    } else if (ti->type == TRACK_AMIGADOS) {

	decode_amigados (drv);

    } else {
	unsigned int i;
	int base_offset = ti->type == TRACK_RAW ? 0 : 1;
	drv->tracklen = ti->bitlen + 16 * base_offset;
	drv->bigmfmbuf[0] = ti->sync;
	read_floppy_data (drv->diskfile, ti, 0, drv->bigmfmbuf + base_offset, (ti->bitlen + 7) / 8);
	for (i = base_offset; i < (drv->tracklen + 15) / 16; i++) {
	    uae_u16 *mfm = drv->bigmfmbuf + i;
	    uae_u8 *data = (uae_u8 *) mfm;
	    *mfm = 256 * *data + *(data + 1);
	}
	if (disk_debug_logging > 1)
	    write_log ("rawtrack %d image offset=%x\n", tr, ti->offs);
    }
    drv->buffered_side = side;
    drv->buffered_cyl = drv->cyl;
    if (drv->tracklen == 0) {
	drv->tracklen = FLOPPY_WRITE_LEN * drv->ddhd * 2 * 8;
	memset (drv->bigmfmbuf, 0, FLOPPY_WRITE_LEN * 2 * drv->ddhd);
    }
    drv->trackspeed = get_floppy_speed () * drv->tracklen / (2 * 8 * FLOPPY_WRITE_LEN * drv->ddhd);
    updatemfmpos (drv);
}

/* Update ADF_EXT2 track header */
static void diskfile_update (struct zfile *diskfile, trackid *ti, int len, uae_u8 type)
{
    uae_u8 buf[2 + 2 + 4 + 4], *zerobuf;

    ti->bitlen = len;
    zfile_fseek (diskfile, 8 + 4 + (2 + 2 + 4 + 4) * ti->track, SEEK_SET);
    memset (buf, 0, sizeof buf);
    ti->type = type;
    buf[3] = ti->type;
    do_put_mem_long ((uae_u32 *) (buf + 4), ti->len);
    do_put_mem_long ((uae_u32 *) (buf + 8), ti->bitlen);
    zfile_fwrite (buf, sizeof (buf), 1, diskfile);
    if (ti->len > (len + 7) / 8) {
	zerobuf = malloc (ti->len);
	memset (zerobuf, 0, ti->len);
	zfile_fseek (diskfile, ti->offs, SEEK_SET);
	zfile_fwrite (zerobuf, 1, ti->len, diskfile);
	free (zerobuf);
    }
    if (disk_debug_logging > 0)
	write_log ("track %d, raw track length %d written (total size %d)\n", ti->track, (ti->bitlen + 7) / 8, ti->len);
}

#define MFMMASK 0x55555555
static uae_u16 getmfmword (const uae_u16 *mbuf, unsigned int shift)
{
    return (mbuf[0] << shift) | (mbuf[1] >> (16 - shift));
}

static uae_u32 getmfmlong (const uae_u16 *mbuf, unsigned int shift)
{
    return ((getmfmword (mbuf, shift) << 16) | getmfmword (mbuf + 1, shift)) & MFMMASK;
}

static int decode_buffer (uae_u16 *mbuf, unsigned int cyl, unsigned int drvsec, unsigned int ddhd, int filetype, unsigned int *drvsecp, int checkmode)
{
    unsigned int i;
    int secwritten = 0;
    unsigned int fwlen = FLOPPY_WRITE_LEN * ddhd;
    unsigned int length = 2 * fwlen;
    uae_u32 odd, even, chksum, id, dlong;
    uae_u8 *secdata;
    uae_u8 secbuf[544];
    uae_u16 *mend = mbuf + length;
    char sectable[22];
    unsigned int shift = 0;

    memset (sectable, 0, sizeof (sectable));
    memcpy (mbuf + fwlen, mbuf, fwlen * sizeof (uae_u16));
    mend -= (4 + 16 + 8 + 512);
    while (secwritten < (int)drvsec) {
	unsigned int trackoffs;

	while (getmfmword (mbuf, shift) != 0x4489) {
	    if (mbuf >= mend)
		return 1;
	    shift++;
	    if (shift == 16) {
		shift = 0;
		mbuf++;
	    }
	}
	while (getmfmword (mbuf, shift) == 0x4489) {
	    if (mbuf >= mend)
		return 1;
	    mbuf++;
	}

	odd = getmfmlong (mbuf, shift);
	even = getmfmlong (mbuf + 2, shift);
	mbuf += 4;
	id = (odd << 1) | even;

	trackoffs = (id & 0xff00) >> 8;
	if (trackoffs + 1 > drvsec) {
	    write_log ("Disk decode: weird sector number %d\n", trackoffs);
	    if (filetype == ADF_EXT2)
		return 2;
	    continue;
	}
	chksum = odd ^ even;
	for (i = 0; i < 4; i++) {
	    odd = getmfmlong (mbuf, shift);
	    even = getmfmlong (mbuf + 8, shift);
	    mbuf += 2;

	    dlong = (odd << 1) | even;
	    if (dlong && !checkmode) {
		if (filetype == ADF_EXT2)
		    return 6;
		secwritten = -200;
	    }
	    chksum ^= odd ^ even;
	}   /* could check here if the label is nonstandard */
	mbuf += 8;
	odd = getmfmlong (mbuf, shift);
	even = getmfmlong (mbuf + 2, shift);
	mbuf += 4;
	if (((odd << 1) | even) != chksum || ((id & 0x00ff0000) >> 16) != (unsigned int)(cyl * 2 + side)) {
	    write_log ("Disk decode: checksum error on sector %d header\n", trackoffs);
	    if (filetype == ADF_EXT2)
		return 3;
	    continue;
	}
	odd = getmfmlong (mbuf, shift);
	even = getmfmlong (mbuf + 2, shift);
	mbuf += 4;
	chksum = (odd << 1) | even;
	secdata = secbuf + 32;
	for (i = 0; i < 128; i++) {
	    odd = getmfmlong (mbuf, shift);
	    even = getmfmlong (mbuf + 256, shift);
	    mbuf += 2;
	    dlong = (odd << 1) | even;
	    *secdata++ = dlong >> 24;
	    *secdata++ = dlong >> 16;
	    *secdata++ = dlong >> 8;
	    *secdata++ = dlong;
	    chksum ^= odd ^ even;
	}
	if (chksum) {
	    write_log ("Disk decode: sector %d, data checksum error\n", trackoffs);
	    if (filetype == ADF_EXT2)
		return 4;
	    continue;
	}
	mbuf += 256;
	sectable[trackoffs] = 1;
	secwritten++;
	memcpy (writebuffer + trackoffs * 512, secbuf + 32, 512);
    }
    if (filetype == ADF_EXT2 && (secwritten == 0 || secwritten < 0))
	return 5;
    if (secwritten == 0)
	write_log ("Disk decode: unsupported format\n");
    if (secwritten < 0)
	write_log ("Disk decode: sector labels ignored\n");
    *drvsecp = drvsec;
    return 0;
}

static uae_u8 mfmdecode (uae_u16 **mfmp, int shift)
{
    uae_u16 mfm = getmfmword (*mfmp, shift);
    uae_u8 out = 0;
    unsigned int i;

    (*mfmp)++;
    mfm &= 0x5555;
    for (i = 0; i < 8; i++) {
	out >>= 1;
	if (mfm & 1)
	    out |= 0x80;
	mfm >>= 2;
    }
    return out;
}

static int drive_write_pcdos (drive *drv)
{
    int i;
    unsigned int drvsec = drv->num_secs;
    unsigned int fwlen = FLOPPY_WRITE_LEN * drv->ddhd;
    int length = 2 * fwlen;
    uae_u16 *mbuf = drv->bigmfmbuf;
    uae_u16 *mend = mbuf + length;
    unsigned int secwritten = 0, shift = 0;
    int sector = -1;
    char sectable[18];
    uae_u8 secbuf[3 + 1 + 512];
    uae_u8 mark;
    uae_u16 crc;

    memset (sectable, 0, sizeof (sectable));
    memcpy (mbuf + fwlen, mbuf, fwlen * sizeof (uae_u16));
    mend -= 518;
    secbuf[0] = secbuf[1] = secbuf[2] = 0xa1;
    secbuf[3] = 0xfb;

    while (secwritten < drvsec) {
	while (getmfmword (mbuf, shift) != 0x4489) {
	    if (mbuf >= mend)
		return 1;
	    shift++;
	    if (shift == 16) {
		shift = 0;
		mbuf++;
	    }
	}
	while (getmfmword (mbuf, shift) == 0x4489) {
	    if (mbuf >= mend)
		return 1;
	    mbuf++;
	}
	mark = mfmdecode (&mbuf, shift);
	if (mark == 0xfe) {
	    uae_u8 tmp[8];
	    uae_u8 cyl, head, size;

	    cyl = mfmdecode (&mbuf, shift);
	    head = mfmdecode (&mbuf, shift);
	    sector = mfmdecode (&mbuf, shift);
	    size = mfmdecode (&mbuf, shift);
	    crc = (mfmdecode (&mbuf, shift) << 8) | mfmdecode (&mbuf, shift);

	    tmp[0] = 0xa1; tmp[1] = 0xa1; tmp[2] = 0xa1; tmp[3] = mark;
	    tmp[4] = cyl; tmp[5] = head; tmp[6] = sector; tmp[7] = size;
	    if (get_crc16 (tmp, 8) != crc || cyl != drv->cyl || head != side || size != 2 || sector < 1 || sector > (int)drv->num_secs) {
		write_log ("PCDOS: track %d, corrupted sector header\n", drv->cyl * 2 + side);
		return 1;
	    }
	    sector--;
	    continue;
	}
	if (mark != 0xfb) {
	    write_log ("PCDOS: track %d: unknown address mark %02.2X\n", drv->cyl * 2 + side, mark);
	    continue;
	}
	if (sector < 0)
	    continue;
	for (i = 0; i < 512; i++)
	    secbuf[i + 4] = mfmdecode (&mbuf, shift);
	crc = (mfmdecode (&mbuf, shift) << 8) | mfmdecode (&mbuf, shift);
	if (get_crc16(secbuf, 3 + 1 + 512) != crc) {
	    write_log ("PCDOS: track %d, sector %d data checksum error\n",
		drv->cyl * 2 + side, sector + 1);
	    continue;
	}
	sectable[sector] = 1;
	secwritten++;
	zfile_fseek (drv->diskfile, drv->trackdata[drv->cyl * 2 + side].offs + sector * 512, SEEK_SET);
	zfile_fwrite (secbuf + 4, sizeof (uae_u8), 512, drv->diskfile);
	write_log ("PCDOS: track %d sector %d written\n", drv->cyl * 2 + side, sector + 1);
	sector = -1;
    }
    if (secwritten != drv->num_secs)
	write_log ("PCDOS: track %d, %d corrupted sectors ignored\n",
	    drv->cyl * 2 + side, drv->num_secs - secwritten);
    return 0;
}

static int drive_write_adf_amigados (drive *drv)
{
    unsigned int drvsec, i;

    if (decode_buffer (drv->bigmfmbuf, drv->cyl, drv->num_secs, drv->ddhd, drv->filetype, &drvsec, 0))
	return 2;
    if (!drvsec)
	return 2;

    if (drv->filetype == ADF_EXT2)
	diskfile_update (drv->diskfile, &drv->trackdata[drv->cyl * 2 + side], drvsec * 512 * 8, TRACK_AMIGADOS);
    for (i = 0; i < drvsec; i++) {
	zfile_fseek (drv->diskfile, drv->trackdata[drv->cyl * 2 + side].offs + i * 512, SEEK_SET);
	zfile_fwrite (writebuffer + i * 512, sizeof (uae_u8), 512, drv->diskfile);
    }

    return 0;
}

/* write raw track to disk file */
static int drive_write_ext2 (uae_u16 *bigmfmbuf, struct zfile *diskfile, trackid *ti, int tracklen)
{
    int len, i;

    len = (tracklen + 7) / 8;
    if (len > ti->len) {
	write_log ("disk raw write: image file's track %d is too small (%d < %d)!\n", ti->track, ti->len, len);
	len = ti->len;
    }
    diskfile_update (diskfile, ti, tracklen, TRACK_RAW);
    for (i = 0; i < ti->len / 2; i++) {
	uae_u16 *mfm = bigmfmbuf + i;
	uae_u16 *mfmw = bigmfmbufw + i;
	uae_u8 *data = (uae_u8 *) mfm;
	*mfmw = 256 * *data + *(data + 1);
    }
    zfile_fseek (diskfile, ti->offs, SEEK_SET);
    zfile_fwrite (bigmfmbufw, 1, len, diskfile);
    return 1;
}

static void drive_write_data (drive * drv)
{
    int ret = -1;
    static int warned;

    if (drive_writeprotected (drv)) {
	/* read original track back because we didn't really write anything */
	drv->buffered_side = 2;
	return;
    }
    if (drv->writediskfile) {
	drive_write_ext2 (drv->bigmfmbuf, drv->writediskfile, &drv->writetrackdata[drv->cyl * 2 + side],
	    longwritemode ? (unsigned int)dsklength2 * 8 : drv->tracklen);
    }
    switch (drv->filetype) {
    case ADF_NORMAL:
	if (drive_write_adf_amigados (drv)) {
	    if (!warned)
#if 0
		notify_user (NUMSG_NEEDEXT2);
#endif
	    warned = 1;
	}
	return;
    case ADF_EXT1:
	break;
    case ADF_EXT2:
	if (!longwritemode)
	    ret = drive_write_adf_amigados (drv);
	if (ret) {
	    write_log ("not an amigados track %d (error %d), writing as raw track\n", drv->cyl * 2 + side, ret);
	    drive_write_ext2 (drv->bigmfmbuf, drv->diskfile, &drv->trackdata[drv->cyl * 2 + side],
		longwritemode ? (unsigned int)dsklength2 * 8 : drv->tracklen);
	}
	return;
    case ADF_IPF:
	break;
    case ADF_PCDOS:
	ret = drive_write_pcdos (drv);
	if (ret)
	    write_log ("not a PC formatted track %d (error %d)\n", drv->cyl * 2 + side, ret);
	break;
    case ADF_FDI:
    case ADF_CATWEASEL:
	break;
    }
    drv->tracktiming[0] = 0;
}

static void drive_eject (drive * drv)
{
#ifdef DRIVESOUND
    driveclick_insert (drv - floppy, 1);
#endif
    drive_image_free (drv);
    drv->dskchange = 1;
    drv->ddhd = 1;
    drv->dskchange_time = 0;
    drv->dskready = 0;
    drv->dskready_time = 0;
    drv->dskready_down_time = 0;
    drv->crc32 = 0;
    drive_settype_id (drv); /* Back to 35 DD */
    if (disk_debug_logging > 0)
        write_log ("eject drive %d\n", drv - &floppy[0]);
}

/* We use this function if we have no Kickstart ROM.
 * No error checking - we trust our luck. */
void DISK_ersatz_read (int tr, int sec, uaecptr dest)
{
    uae_u8 *dptr = get_real_address (dest);
    zfile_fseek (floppy[0].diskfile, floppy[0].trackdata[tr].offs + sec * 512, SEEK_SET);
    zfile_fread (dptr, 1, 512, floppy[0].diskfile);
}

/* type: 0=regular, 1=ext2adf */
/* adftype: 0=DD,1=HD,2=525SD */
void disk_creatediskfile (char *name, int type, drive_type adftype, const char *disk_name)
{
    struct zfile *f;
    int i, l, file_size, tracks, track_len;
    uae_u8 *chunk = NULL;
    uae_u8 tmp[3*4];

    if (disk_name == NULL || strlen (disk_name) == 0)
	disk_name = "empty";

    if (type == 1)
	tracks = 2 * 83;
    else
	tracks = 2 * 80;
    file_size = 880 * 1024;
    track_len = FLOPPY_WRITE_LEN * 2;
    if (adftype == 1) {
	file_size *= 2;
	track_len *= 2;
    } else if (adftype == 2) {
	file_size /= 2;
	tracks /= 2;
    }

    f = zfile_fopen (name, "wb");
    chunk = xmalloc (16384);
    if (f && chunk) {
	memset (chunk,0,16384);
	if (type == 0 && adftype < 2) {
	    for (i = 0; i < file_size; i += 11264) {
		memset (chunk, 0, 11264);
		if (i == 0) {
		    /* boot block */
		    strcpy ((char *) chunk, "DOS");
		} else if (i == file_size / 2) {
		    int block = file_size / 1024;
		    /* root block */
		    chunk[0+3] = 2;
		    chunk[12+3] = 0x48;
		    chunk[312] = chunk[313] = chunk[314] = chunk[315] = (uae_u8)0xff;
		    chunk[316+2] = (block + 1) >> 8; chunk[316+3] = (block + 1) & 255;
		    chunk[432] = strlen (disk_name);
		    strcpy ((char *)chunk + 433, disk_name);
		    chunk[508 + 3] = 1;
		    disk_date (chunk + 420);
		    memcpy (chunk + 472, chunk + 420, 3 * 4);
		    memcpy (chunk + 484, chunk + 420, 3 * 4);
		    disk_checksum (chunk, chunk + 20);
		    /* bitmap block */
		    memset (chunk + 512 + 4, 0xff, 2 * file_size / (1024 * 8));
		    if (adftype == 0)
			chunk[512 + 0x72] = 0x3f;
		    else
			chunk[512 + 0xdc] = 0x3f;
		    disk_checksum (chunk + 512, chunk + 512);

		}
		zfile_fwrite (chunk, 11264, 1, f);
	    }
	} else {
	    l = track_len;
	    zfile_fwrite ("UAE-1ADF", 8, 1, f);
	    tmp[0] = 0; tmp[1] = 0; /* flags (reserved) */
	    tmp[2] = 0; tmp[3] = tracks; /* number of tracks */
	    zfile_fwrite (tmp, 4, 1, f);
	    tmp[0] = 0; tmp[1] = 0; /* flags (reserved) */
	    tmp[2] = 0; tmp[3] = 1; /* track type */
	    tmp[4] = 0; tmp[5] = 0; tmp[6]=(uae_u8)(l >> 8); tmp[7] = (uae_u8)l;
	    tmp[8] = 0; tmp[9] = 0; tmp[10] = 0; tmp[11] = 0;
	    for (i = 0; i < tracks; i++) zfile_fwrite (tmp, sizeof (tmp), 1, f);
	    for (i = 0; i < tracks; i++) zfile_fwrite (chunk, l, 1, f);
	}
    }
    free (chunk);
    zfile_fclose (f);
}

int disk_getwriteprotect (const char *name)
{
    int needwritefile;
    drive_type drvtype;
    return diskfile_iswriteprotect (name, &needwritefile, &drvtype);
}

static void diskfile_readonly (const char *name, int readonly)
{
    struct stat st;
    int mode, oldmode;

    if (stat (name, &st))
	return;
    oldmode = mode = st.st_mode;
//    mode &= ~FILEFLAG_WRITE;
//    if (!readonly) mode |= FILEFLAG_WRITE;
    if (mode != oldmode)
	chmod (name, mode);
}

static void setdskchangetime (drive *drv, int dsktime)
{
    int i;
    /* prevent multiple disk insertions at the same time */
    if (drv->dskchange_time > 0)
	return;
    for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
	if (&floppy[i] != drv && floppy[i].dskchange_time > 0 && floppy[i].dskchange_time + 5 >= dsktime) {
	    dsktime = floppy[i].dskchange_time + 5;
	}
    }
    drv->dskchange_time = dsktime;
    if (disk_debug_logging > 0)
	write_log ("delayed insert enable %d\n", dsktime);
}

void DISK_reinsert (int num)
{
    drive_eject (&floppy[num]);
    setdskchangetime (&floppy[num], 20);
}

int disk_setwriteprotect (int num, const char *name, int protect)
{
    int needwritefile, oldprotect;
    struct zfile *zf1, *zf2;
    int wrprot1, wrprot2, i;
    char *name2;
    drive_type drvtype;

    oldprotect = diskfile_iswriteprotect (name, &needwritefile, &drvtype);
    zf1 = DISK_validate_filename (name, 1, &wrprot1, NULL);
    if (!zf1)
	return 0;
    if (zfile_iscompressed (zf1))
	wrprot1 = 1;
    zfile_fclose (zf1);
    zf2 = getwritefile (name, &wrprot2);
    name2 = DISK_get_saveimagepath (name);

    if (needwritefile && zf2 == 0)
	disk_creatediskfile (name2, 1, drvtype, NULL);
    zfile_fclose (zf2);
    if (protect && iswritefileempty (name)) {
	for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
	    if (!strcmp (name, floppy[i].newname))
		drive_eject (&floppy[i]);
	}
	unlink (name2);
    }

    if (!needwritefile)
	diskfile_readonly (name, protect);
    diskfile_readonly (name2, protect);
    DISK_reinsert (num);
    return 1;
}

void disk_eject (int num)
{
    gui_filename (num, "");
    drive_eject (floppy + num);
    *currprefs.df[num] = *changed_prefs.df[num] = 0;
    floppy[num].newname[0] = 0;
    update_drive_gui (num);
}

int DISK_history_add (const char *name, int idx)
{
    int i;

    if (idx >= MAX_PREVIOUS_FLOPPIES)
	return 0;
    if (name == NULL) {
	dfxhistory[idx][0] = 0;
	return 1;
    }
    if (name[0] == 0)
	return 0;
    if (!zfile_exists (name))
	return 0;
    if (idx >= 0) {
	if (idx >= MAX_PREVIOUS_FLOPPIES)
	    return 0;
	dfxhistory[idx][0] = 0;
	for (i = 0; i < MAX_PREVIOUS_FLOPPIES; i++) {
	    if (!strcmp (dfxhistory[i], name))
		return 0;
	}
	strcpy (dfxhistory[idx], name);
	return 1;
    }
    for (i = 0; i < MAX_PREVIOUS_FLOPPIES; i++) {
	if (!strcmp (dfxhistory[i], name)) {
	    while (i < MAX_PREVIOUS_FLOPPIES - 1) {
		strcpy (dfxhistory[i], dfxhistory[i + 1]);
		i++;
	    }
	    dfxhistory[MAX_PREVIOUS_FLOPPIES - 1][0] = 0;
	    break;
	}
    }
    for (i = MAX_PREVIOUS_FLOPPIES - 2; i >= 0; i--)
	strcpy (dfxhistory[i + 1], dfxhistory[i]);
    strcpy (dfxhistory[0], name);
    return 1;
}

char *DISK_history_get (int idx)
{
    if (idx >= MAX_PREVIOUS_FLOPPIES)
	return 0;
    return dfxhistory[idx];
}

static void disk_insert_2 (int num, const char *name, int forced)
{
    drive *drv = floppy + num;

    if (forced) {
	drive_insert (drv, &currprefs, num, name);
	return;
    }
    if (!strcmp (currprefs.df[num], name))
	return;
    strcpy (drv->newname, name);
    strcpy (currprefs.df[num], name);
    DISK_history_add (name, -1);
    if (name[0] == 0) {
	disk_eject (num);
    } else if (!drive_empty (drv) || drv->dskchange_time > 0) {
	drive_eject (drv);
	/* set dskchange_time, disk_insert() will be
	 * called from DISK_check_change() after 2 second delay
	 * this makes sure that all programs detect disk change correctly
	 */
	setdskchangetime (drv, 20);
    } else {
	setdskchangetime (drv, 1);
    }
}

void disk_insert (int num, const char *name)
{
    disk_insert_2 (num, name, 0);
}

void disk_insert_force (int num, const char *name)
{
    disk_insert_2 (num, name, 1);
}

void DISK_check_change (void)
{
    int i;

    if (currprefs.floppy_speed != changed_prefs.floppy_speed)
	currprefs.floppy_speed = changed_prefs.floppy_speed;
    for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
	drive *drv = floppy + i;

	if (currprefs.dfxtype[i] != changed_prefs.dfxtype[i]) {
	    currprefs.dfxtype[i] = changed_prefs.dfxtype[i];
	    reset_drive (i);
	}
	if (strcmp (currprefs.df[i], changed_prefs.df[i]))
	    disk_insert (i, changed_prefs.df[i]);

	if (drv->dskready_down_time > 0)
	    drv->dskready_down_time--;
#if 1
	/* emulate drive motor turn on time */
	if (drv->dskready_time) {
	    drv->dskready_time--;
	    if (drv->dskready_time == 0)
		drv->dskready = 1;
	}
#endif
	/* delay until new disk image is inserted */
	if (drv->dskchange_time) {
	    drv->dskchange_time--;
	    if (drv->dskchange_time == 0) {
		drive_insert (drv, &currprefs, i, drv->newname);
		if (disk_debug_logging > 0)
		    write_log ("delayed insert, drive %d, image '%s'\n", i, drv->newname);
		update_drive_gui (i);

	    }
	}
    }
}

int disk_empty (int num)
{
    return drive_empty (floppy + num);
}

static char *tobin (uae_u8 v)
{
    int i;
    static char buf[10];
    for ( i = 7; i >= 0; i--)
	buf[7 - i] = v & (1 << i) ? '1' : '0';
    buf[i] = 0;
    return buf;
}

void DISK_select (uae_u8 data)
{
    unsigned int step_pulse, lastselected, dr;
    static uae_u8 prevdata;
    static unsigned int step;

    if (disk_debug_logging > 1)
	write_log ("%08.8X %02.2X %s", m68k_getpc (&regs), data, tobin (data));

    lastselected = selected;
    selected = (data >> 3) & 15;
    side = 1 - ((data >> 2) & 1);
    direction = (data >> 1) & 1;
    step_pulse = data & 1;

    if ((prevdata & 0x80) != (data & 0x80)) {
	for (dr = 0; dr < 4; dr++) {
	    if (floppy[dr].indexhackmode > 1 && !(selected & (1 << dr))) {
		floppy[dr].indexhack = 1;
		if (disk_debug_logging > 1)
		    write_log (" indexhack!");
	    }
	}
    }

    if (disk_debug_logging > 1) {
	write_log (" %d%d%d%d% ", (selected & 1) ? 0 : 1, (selected & 2) ? 0 : 1, (selected & 4) ? 0 : 1, (selected & 8) ? 0 : 1);
	if ((prevdata & 0x80) != (data & 0x80))
	    write_log (" dskmotor %d ", (data & 0x80) ? 1 : 0);
	if ((prevdata & 0x02) != (data & 0x02))
	    write_log (" direct %d ", (data & 0x02) ? 1 : 0);
	if ((prevdata & 0x04) != (data & 0x04))
	    write_log (" side %d ", (data & 0x04) ? 1 : 0);
    }

    selected |= disabled;

    if (step != step_pulse) {
	if (disk_debug_logging > 1)
	    write_log (" dskstep %d ", step_pulse);
	step = step_pulse;
	if (step && !savestate_state) {
	    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
		if (!(selected & (1 << dr))) {
		    drive_step (floppy + dr);
		    if (floppy[dr].indexhackmode > 1 && (data & 0x80))
			floppy[dr].indexhack = 1;
		}
	    }
	}
    }
    if (!savestate_state) {
	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	    drive *drv = floppy + dr;
	    /* motor on/off workings tested with small assembler code on real Amiga 1200. */
	    /* motor/id flipflop is set only when drive select goes from high to low */
	    if (!(selected & (1 << dr)) && (lastselected & (1 << dr)) ) {
		drv->drive_id_scnt++;
		drv->drive_id_scnt &= 31;
		drv->idbit = (drv->drive_id & (1L << (31 - drv->drive_id_scnt))) ? 1 : 0;
		if ((prevdata & 0x80) == 0 || (data & 0x80) == 0) {
		    /* motor off: if motor bit = 0 in prevdata or data -> turn motor on */
		    drive_motor (drv, 0);
		} else if (prevdata & 0x80) {
		    /* motor on: if motor bit = 1 in prevdata only (motor flag state in data has no effect)
			-> turn motor off */
		    drive_motor (drv, 1);
		}
		if (currprefs.dfxtype[dr] == DRV_35_DD) {
		    if (dr == 0) /* A500/A2000 internal drive always returns 0 */
			drv->idbit = 0;
		    else /* regular external DD drive always returns 1 */
			drv->idbit = 1;
		}
#ifdef DEBUG_DRIVE_ID
		write_log ("DISK_status: sel %d id %s (%08.8X) [0x%08lx, bit #%02d: %d]\n",
		    dr, drive_id_name (drv), drv->drive_id, drv->drive_id << drv->drive_id_scnt, 31 - drv->drive_id_scnt, drv->idbit);
#endif
	    }
	}
    }
    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	floppy[dr].state = (!(selected & (1 << dr))) | !floppy[dr].motoroff;
	update_drive_gui (dr);
    }
    prevdata = data;
    if (disk_debug_logging > 1)
        write_log ("\n");
}

uae_u8 DISK_status (void)
{
    uae_u8 st = 0x3c;
    unsigned int dr;

    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv = floppy + dr;
	if (!(selected & (1 << dr))) {
	    if (drive_running (drv)) {
		if (drv->catweasel) {
#ifdef CATWEASEL
		    if (catweasel_diskready (drv->catweasel))
			st &= ~0x20;
#endif
		} else {
		    if (drv->dskready && !drv->indexhack && currprefs.dfxtype[dr] != DRV_35_DD_ESCOM)
			st &= ~0x20;
		}
	    } else {
		/* report drive ID */
		if (drv->idbit && currprefs.dfxtype[dr] != DRV_35_DD_ESCOM)
		    st &= ~0x20;
		/* dskrdy needs some cycles after switching the motor off.. (Pro Tennis Tour) */
		if (drv->motordelay) {
		    write_log ("MOTORDELAY! %x\n", m68k_getpc (&regs));
		    st &= ~0x20;
		    drv->motordelay = 0;
		}
	    }
	    if (drive_track0 (drv))
		st &= ~0x10;
	    if (drive_writeprotected (drv))
		st &= ~8;
	    if (drv->catweasel) {
#ifdef CATWEASEL
		if (catweasel_disk_changed (drv->catweasel))
		    st &= ~4;
#endif
	    } else if (drv->dskchange && currprefs.dfxtype[dr] != DRV_525_SD) {
		st &= ~4;
	    }
	}
    }
    return st;
}

static int unformatted (drive *drv)
{
    unsigned int tr = drv->cyl * 2 + side;
    if (tr >= drv->num_tracks)
	return 1;
    if (drv->filetype == ADF_EXT2 && drv->trackdata[tr].bitlen == 0)
	return 1;
    return 0;
}

/* get one bit from MFM bit stream */
STATIC_INLINE uae_u32 getonebit (uae_u16 * mfmbuf, unsigned int mfmpos)
{
    uae_u16 *buf;

    buf = &mfmbuf[mfmpos >> 4];
    return (buf[0] & (1 << (15 - (mfmpos & 15)))) ? 1 : 0;
}

void dumpdisk (void)
{
    int i, j, k;
    uae_u16 w;

    for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
	drive *drv = &floppy[i];
	if (!(disabled & (1 << i))) {
	    write_log ("Drive %d: motor %s cylinder %2d sel %s %s mfmpos %d/%d\n",
		i, drv->motoroff ? "off" : " on", drv->cyl, (selected & (1 << i)) ? "no" : "yes",
		drive_writeprotected (drv) ? "ro" : "rw", drv->mfmpos, drv->tracklen);
	    w = word;
	    for (j = 0; j < 15; j++) {
		write_log ("%04.4X ", w);
		for (k = 0; k < 16; k++) {
		    w <<= 1;
		    w |= getonebit (drv->bigmfmbuf, drv->mfmpos + j * 16 + k);
		}
	    }
	    write_log ("\n");
	}
    }
    write_log ("side %d, dma %d, bitoffset %d, word %04.4X, dskbytr %04.4X adkcon %04.4X dsksync %04.4X\n", side, dskdmaen, bitoffset, word, dskbytr_val, adkcon, dsksync);
}

static void disk_dmafinished (void)
{
    INTREQ (0x8002);
    longwritemode = 0;
    dskdmaen = 0;
    if (disk_debug_logging > 0) {
	unsigned int dr;
	write_log ("disk dma finished %08.8X MFMpos=", dskpt);
	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++)
	    write_log ("%d%s", floppy[dr].mfmpos, dr < MAX_FLOPPY_DRIVES - 1 ? "," : "");
	write_log ("\n");
    }
}

static void fetchnextrevolution (drive *drv)
{
    drv->trackspeed = get_floppy_speed () * drv->tracklen / (2 * 8 * FLOPPY_WRITE_LEN * drv->ddhd);
    if (!drv->multi_revolution)
	return;
    switch (drv->filetype)
    {
	case ADF_IPF:
#ifdef CAPS
	caps_loadrevolution (drv->bigmfmbuf, drv - floppy, drv->cyl * 2 + side, &drv->tracklen);
#endif
	break;
	case ADF_FDI:
#ifdef FDI2RAW
	fdi2raw_loadrevolution (drv->fdi, drv->bigmfmbuf, drv->tracktiming, drv->cyl * 2 + side, &drv->tracklen, 1);
#endif
	break;
	default:
	break;
    }
}

void DISK_handler (void)
{
    int flag = diskevent_flag;
    eventtab[ev_disk].active = 0;
    DISK_update (disk_sync_cycle);
    if (flag & (DISK_REVOLUTION << 0))
	fetchnextrevolution (&floppy[0]);
    if (flag & (DISK_REVOLUTION << 1))
	fetchnextrevolution (&floppy[1]);
    if (flag & (DISK_REVOLUTION << 2))
	fetchnextrevolution (&floppy[2]);
    if (flag & (DISK_REVOLUTION << 3))
	fetchnextrevolution (&floppy[3]);
    if (flag & DISK_WORDSYNC)
	INTREQ (0x8000 | 0x1000);
    if (flag & DISK_INDEXSYNC)
	cia_diskindex ();
    floppy[0].motordelay = floppy[1].motordelay = floppy[2].motordelay = floppy[3].motordelay = 0;
#if 0
	{
	unsigned int i;
	for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
	    drive *drv = &floppy[i];
	    if (drv->dskready_time) {
		drv->dskready_time--;
		if (drv->dskready_time == 0) {
		    drv->dskready = 1;
		    if (disk_debug_logging > 0)
			 write_log ("%d: %d\n", i, drv->mfmpos);
		}
	    }
	}
	}
#endif
}

static void disk_doupdate_write (drive * drv, int floppybits)
{
    int dr;
    int drives[4];

    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv2 = &floppy[dr];
	drives[dr] = 0;
	if (drv2->motoroff)
	    continue;
	if (selected & (1 << dr))
	    continue;
	drives[dr] = 1;
    }

    while (floppybits >= drv->trackspeed) {
	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	    if (drives[dr]) {
		floppy[dr].mfmpos++;
		floppy[dr].mfmpos %= drv->tracklen;
	    }
	}
	if ((dmacon & 0x210) == 0x210 && dskdmaen == 3 && dsklength > 0) {
	    bitoffset++;
	    bitoffset &= 15;
	    if (!bitoffset) {
		for (dr = 0; dr < MAX_FLOPPY_DRIVES ; dr++) {
		    drive *drv2 = &floppy[dr];
		    if (drives[dr])
			drv2->bigmfmbuf[drv2->mfmpos >> 4] = get_word (dskpt);
		}
		dskpt += 2;
		dsklength--;
		if (dsklength == 0) {
		    disk_dmafinished ();
		    for (dr = 0; dr < MAX_FLOPPY_DRIVES ; dr++) {
			drive *drv2 = &floppy[dr];
			if (drives[dr])
			    drive_write_data (drv2);
		    }
		}
	    }
	}
	floppybits -= drv->trackspeed;
    }
}

static void updatetrackspeed (drive *drv, unsigned int mfmpos)
{
    if (dskdmaen < 3) {
	uae_u16 *p = drv->tracktiming;
	p += mfmpos / 8;
	drv->trackspeed = get_floppy_speed () * drv->tracklen / (2 * 8 * FLOPPY_WRITE_LEN * drv->ddhd);
	drv->trackspeed = drv->trackspeed * p[0] / 1000;
	if (drv->trackspeed < 700 || drv->trackspeed > 3000) {
	    static int warned;
	    warned++;
	    if (warned < 50)
		write_log ("corrupted trackspeed value %d\n", drv->trackspeed);
//	    assert (0);
	}
    }
}

static void disk_doupdate_predict (drive * drv, unsigned int startcycle)
{
    unsigned int firstcycle = startcycle;
    uae_u32 tword = word;
    unsigned int mfmpos = drv->mfmpos;
    int indexhack = drv->indexhack;
    int is_empty       = drive_empty (drv);
    int is_unformatted = unformatted (drv);

    diskevent_flag = 0;
    while (startcycle < (maxhpos << 8) && !diskevent_flag) {
	if (drv->tracktiming[0])
	    updatetrackspeed (drv, mfmpos);
	if (dskdmaen != 3) {
	    tword <<= 1;
	    if (!is_empty) {
		if (is_unformatted)
		    tword |= (rand () & 0x1000) ? 1 : 0;
		else
		    tword |= getonebit (drv->bigmfmbuf, mfmpos);
	    }
	    if ((tword & 0xffff) == dsksync)
		diskevent_flag |= DISK_WORDSYNC;
	}
	mfmpos++;
	mfmpos %= drv->tracklen;
	if (mfmpos == 0)
	    diskevent_flag |= DISK_REVOLUTION << (drv - floppy);
	if (mfmpos == drv->indexoffset) {
	    diskevent_flag |= DISK_INDEXSYNC;
	    indexhack = 0;
	}
	if (dskdmaen != 3 && (int)mfmpos == drv->skipoffset) {
	    int skipcnt = disk_jitter;
	    while (skipcnt-- > 0) {
		mfmpos++;
		mfmpos %= drv->tracklen;
		if (mfmpos == 0)
		    diskevent_flag |= DISK_REVOLUTION << (drv - floppy);
		if (mfmpos == drv->indexoffset) {
		    diskevent_flag |= DISK_INDEXSYNC;
		    indexhack = 0;
		}
	    }
	}
	startcycle += drv->trackspeed;
    }
    if (drv->tracktiming[0])
	updatetrackspeed (drv, drv->mfmpos);
    if (diskevent_flag) {
	disk_sync_cycle = startcycle >> 8;
	eventtab[ev_disk].oldcycles = get_cycles ();
	eventtab[ev_disk].evtime = get_cycles () + startcycle - firstcycle;
	eventtab[ev_disk].active = 1;
	events_schedule ();
    }
}

#ifdef CPUEMU_6
extern uae_u8 cycle_line[256];
#endif

static void disk_doupdate_read (drive * drv, int floppybits)
{
//    int j = 0, k = 1, l = 0;

/*
    uae_u16 *mfmbuf = drv->bigmfmbuf;
    dsksync = 0x4444;
    adkcon |= 0x400;
    drv->mfmpos = 0;
    memset (mfmbuf, 0, 1000);
    cycles = 0x1000000;
    // 4444 4444 4444 aaaa aaaaa 4444 4444 4444
    // 4444 aaaa aaaa 4444
    mfmbuf[0] = 0x4444;
    mfmbuf[1] = 0x4444;
    mfmbuf[2] = 0x4444;
    mfmbuf[3] = 0xaaaa;
    mfmbuf[4] = 0xaaaa;
    mfmbuf[5] = 0x4444;
    mfmbuf[6] = 0x4444;
    mfmbuf[7] = 0x4444;
*/

    int is_empty       = drive_empty (drv);
    int is_unformatted = unformatted (drv);

    while (floppybits >= drv->trackspeed) {
	if (drv->tracktiming[0])
	    updatetrackspeed (drv, drv->mfmpos);
	word <<= 1;
        if (!is_empty) {
	    if (is_unformatted)
		word |= (rand () & 0x1000) ? 1 : 0;
	    else
		word |= getonebit (drv->bigmfmbuf, drv->mfmpos);
	}

	drv->mfmpos++;
	drv->mfmpos %= drv->tracklen;
	if (drv->mfmpos == drv->indexoffset) {
	    if (disk_debug_logging > 1 && drv->indexhack)
		write_log ("indexhack cleared\n");
	    drv->indexhack = 0;
	}
	if ((int)drv->mfmpos == drv->skipoffset) {
	    drv->mfmpos += disk_jitter;
	    drv->mfmpos %= drv->tracklen;
	}
	if (bitoffset == 15 && dma_enable && dskdmaen == 2 && dsklength >= 0) {
	    if (dsklength > 0) {
	        do_chipmem_wput (dskpt, word);
		dskpt += 2;
#ifdef CPUEMU_6
		cycle_line[7] |= CYCLE_MISC;
		cycle_line[9] |= CYCLE_MISC;
#endif
	    }
#if 0
	    dma_tab[j++] = word;
	    if (j == MAX_DISK_WORDS_PER_LINE - 1) {
		write_log ("Bug: Disk DMA buffer overflow!\n");
		j--;
	    }
#endif
	    dsklength--;
	    if (dsklength <= 0)
		disk_dmafinished ();
	}
	if ((bitoffset & 7) == 7) {
	    dskbytr_val = word & 0xff;
	    dskbytr_val |= 0x8000;
	}
	if (word == dsksync) {
	    if (adkcon & 0x400)
		bitoffset = 15;
	    if (dskdmaen) {
		if (disk_debug_logging && dma_enable == 0)
		    write_log ("Sync match, DMA started at %d\n", drv->mfmpos);
		dma_enable = 1;
	    }
	}
	bitoffset++;
	bitoffset &= 15;
	floppybits -= drv->trackspeed;
    }
#if 0
    dma_tab[j] = 0xffffffff;
#endif
}

static void disk_dma_debugmsg (void)
{
    write_log ("LEN=%04.4X (%d) SYNC=%04.4X PT=%08.8X ADKCON=%04.4X PC=%08.8X\n",
	dsklength, dsklength, (adkcon & 0x400) ? dsksync : 0xffff, dskpt, adkcon, m68k_getpc (&regs));
}

#if 0
/* disk DMA fetch happens on real Amiga at the beginning of next horizontal line
   (cycles 9, 11 and 13 according to hardware manual) We transfer all DMA'd
   data at cycle 0. I don't think any program cares about this small difference.
*/
static void dodmafetch (void)
{
    unsigned int i;

    i = 0;
    while (dma_tab[i] != 0xffffffff && dskdmaen != 3 && (dmacon & 0x210) == 0x210) {
	put_word (dskpt, dma_tab[i++]);
	dskpt += 2;
    }
    dma_tab[0] = 0xffffffff;
}
#endif

/* this is very unoptimized. DSKBYTR is used very rarely, so it should not matter. */

uae_u16 DSKBYTR (unsigned int hpos)
{
    uae_u16 v;

    DISK_update (hpos);
    v = dskbytr_val;
    dskbytr_val &= ~0x8000;
    if (word == dsksync)
	v |= 0x1000;
    if (dskdmaen && (dmacon & 0x210) == 0x210)
	v |= 0x4000;
    if (dsklen & 0x4000)
	v |= 0x2000;
    if (disk_debug_logging > 1)
        write_log ("DSKBYTR=%04.4X hpos=%d\n", v, hpos);
#ifdef DEBUGGER
    if (disk_debug_mode & DISK_DEBUG_PIO) {
	unsigned int dr;
	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	    drive *drv = &floppy[dr];
	    if (drv->motoroff)
		continue;
	    if (!(selected & (1 << dr))) {
		if (disk_debug_track < 0 || disk_debug_track == 2 * (int)drv->cyl + side) {
		    disk_dma_debugmsg ();
		    write_log ("DSKBYTR=%04.4X\n", v);
		    activate_debugger ();
		    break;
		}
	    }
	}
    }
#endif

    return v;
}

static void DISK_start (void)
{
    unsigned int dr;

    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv = &floppy[dr];
	if (!(selected & (1 << dr))) {
	    unsigned int tr = drv->cyl * 2 + side;
	    trackid *ti = drv->trackdata + tr;

	    if (dskdmaen == 3) {
		drv->tracklen = longwritemode ? FLOPPY_WRITE_MAXLEN : FLOPPY_WRITE_LEN * drv->ddhd * 8 * 2;
		drv->trackspeed = get_floppy_speed ();
		drv->skipoffset = -1;
		updatemfmpos (drv);
	    }
	    /* Ugh.  A nasty hack.  Assume ADF_EXT1 tracks are always read
	       from the start.  */
	    if (ti->type == TRACK_RAW1)
		drv->mfmpos = 0;
	    if (drv->catweasel)
		drive_fill_bigbuf (drv, 1);
	}
	drv->floppybitcounter = 0;
    }
    dma_enable = (adkcon & 0x400) ? 0 : 1;
}

static int linecounter;

void DISK_hsync (unsigned int tohpos)
{
    unsigned int dr;

    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv = &floppy[dr];
	if (drv->steplimit)
	    drv->steplimit--;
    }
    if (linecounter) {
	linecounter--;
	if (! linecounter)
	    disk_dmafinished ();
	return;
    }
    DISK_update (tohpos);
}

void DISK_update (unsigned int tohpos)
{
    unsigned int dr;
    unsigned int cycles = (tohpos << 8) - disk_hpos;

    disk_jitter = ((rand () >> 4) & 3) + 1;
    if (disk_jitter > 2)
	disk_jitter = 1;
    if (cycles <= 0)
	return;
    disk_hpos += cycles;
    if (disk_hpos >= (maxhpos << 8))
	disk_hpos -= maxhpos << 8;

#if 0
    dodmafetch ();
#endif

    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv = &floppy[dr];

	if (drv->motoroff)
	    continue;
	drv->floppybitcounter += cycles;
	if (selected & (1 << dr)) {
	    drv->mfmpos += drv->floppybitcounter / drv->trackspeed;
	    drv->mfmpos %= drv->tracklen;
	    drv->floppybitcounter %= drv->trackspeed;
	    continue;
	}
	drive_fill_bigbuf (drv, 0);
	drv->mfmpos %= drv->tracklen;
    }
    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv = &floppy[dr];
	if (drv->motoroff)
	    continue;
	if (selected & (1 << dr))
	    continue;
	if (dskdmaen == 3)
	    disk_doupdate_write (drv, drv->floppybitcounter);
	else
	    disk_doupdate_read (drv, drv->floppybitcounter);
	disk_doupdate_predict (drv, disk_hpos);
	drv->floppybitcounter %= drv->trackspeed;
	break;
    }
}

void DSKLEN (uae_u16 v, unsigned int hpos)
{
    unsigned int dr, prev = dsklen;

    DISK_update (hpos);
    if ((v & 0x8000) && (dsklen & 0x8000)) {
	dskdmaen = 2;
	DISK_start ();
    }
    if (!(v & 0x8000)) {
	if (dskdmaen) {
	    /* Megalomania and Knightmare does this */
	    if (disk_debug_logging > 0 && dskdmaen == 2)
		write_log ("warning: Disk read DMA aborted, %d words left PC=%x\n", dsklength, m68k_getpc (&regs));
	    if (dskdmaen == 3)
		write_log ("warning: Disk write DMA aborted, %d words left PC=%x\n", dsklength, m68k_getpc (&regs));
	    dskdmaen = 0;
	}
    }
    dsklen = v;
    dsklength2 = dsklength = dsklen & 0x3fff;

    if (dskdmaen == 0)
	return;

    if ((v & 0x4000) && (prev & 0x4000)) {
	if (dsklength == 0)
	    return;
	if (dsklength == 1) {
	    disk_dmafinished ();
	    return;
	}
	dskdmaen = 3;
	DISK_start ();
    }

    if (dsklength == 1)
	dsklength = 0;

#ifdef DEBUGGER
    if (((disk_debug_mode & DISK_DEBUG_DMA_READ) && dskdmaen == 2) ||
	((disk_debug_mode & DISK_DEBUG_DMA_WRITE) && dskdmaen == 3))
    {
	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	    drive *drv = &floppy[dr];
	    if (drv->motoroff)
		continue;
	    if (!(selected & (1 << dr))) {
		if (disk_debug_track < 0 || disk_debug_track == 2 * (int)drv->cyl + side) {
		    disk_dma_debugmsg ();
		    activate_debugger ();
		    break;
		}
	    }
	}
    }
#endif

    if (disk_debug_logging > 0) {
	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	    drive *drv = &floppy[dr];
	    if (drv->motoroff)
		continue;
	    if ((selected & (1 << dr)) == 0)
		break;
	}
	if (dr == 4) {
	    write_log ("disk %s DMA started but no drive selected!\n",
	       dskdmaen == 3 ? "write" : "read");
	} else {
	    write_log ("disk %s DMA started, drv=%x track %d mfmpos %d\n",
		dskdmaen == 3 ? "write" : "read", selected ^ 15,
		floppy[dr].cyl * 2 + side, floppy[dr].mfmpos);
	}
        disk_dma_debugmsg ();
    }

    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++)
	update_drive_gui (dr);

    /* Try to make floppy access from Kickstart faster.  */
    if (dskdmaen != 2 && dskdmaen != 3)
	return;
    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv = &floppy[dr];
	if (selected & (1 << dr))
	    continue;
	if (drv->filetype != ADF_NORMAL)
	    break;
    }
    if (dr < MAX_FLOPPY_DRIVES) /* no turbo mode if any selected drive has non-standard ADF */
	return;
    {
	int done = 0;
	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	    drive *drv = &floppy[dr];
	    unsigned int pos;

	    if (drv->motoroff)
		continue;
	    if (!drv->useturbo && currprefs.floppy_speed > 0)
		continue;
	    if (selected & (1 << dr))
		continue;

	    pos = drv->mfmpos & ~15;
	    drive_fill_bigbuf (drv, 0);

	    if (dskdmaen == 2) { /* TURBO read */

		if (adkcon & 0x400) {
		    unsigned int i;
		    for (i = 0; i < drv->tracklen; i += 16) {
			pos += 16;
			pos %= drv->tracklen;
			if (drv->bigmfmbuf[pos >> 4] == dsksync) {
			    /* must skip first disk sync marker */
			    pos += 16;
			    pos %= drv->tracklen;
			    break;
			}
		    }
		    if (i >= drv->tracklen)
			return;
		}
		while (dsklength-- > 0) {
		    put_word (dskpt, drv->bigmfmbuf[pos >> 4]);
		    dskpt += 2;
		    pos += 16;
		    pos %= drv->tracklen;
		}
		INTREQ (0x9000);
		done = 1;

	    } else if (dskdmaen == 3) { /* TURBO write */

	        int i;
		for (i = 0; i < dsklength; i++) {
		    drv->bigmfmbuf[pos >> 4] = get_word (dskpt + i * 2);
		    pos += 16;
		    pos %= drv->tracklen;
		}
		drive_write_data (drv);
		done = 1;
	    }
	}
	if (done) {
	    linecounter = 2;
	    dskdmaen = 0;
	    return;
	}
    }
}

void DSKSYNC (unsigned int hpos, uae_u16 v)
{
    if (v == dsksync)
	return;
    DISK_update (hpos);
    dsksync = v;
}

void DSKDAT (uae_u16 v)
{
    static int count = 0;
    if (count < 5) {
	count++;
	write_log ("%04.4X written to DSKDAT. Not good. PC=%08.8X", v, m68k_getpc (&regs));
	if (count == 5)
	    write_log ("(further messages suppressed)");

	write_log ("\n");
    }
}

void DSKPTH (uae_u16 v)
{
    dskpt = (dskpt & 0xffff) | ((uae_u32) v << 16);
}

void DSKPTL (uae_u16 v)
{
    dskpt = (dskpt & ~0xffff) | (v);
}

void DISK_free (void)
{
#ifdef SAVE_MEMORY
    if (floppy) {
#endif
	unsigned int dr;

	for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	    drive *drv = &floppy[dr];
	    drive_image_free (drv);
	}
#ifdef SAVE_MEMORY
	free (floppy);
	floppy = 0;
    }
#endif
}

void DISK_init (void)
{
    unsigned int dr;

#if 0
    dma_tab[0] = 0xffffffff;
#endif

#ifdef SAVE_MEMORY
    floppy = malloc (sizeof (drive) * MAX_FLOPPY_DRIVES);
    if (!floppy)
	abort ();
    memset (floppy, 0, sizeof (drive) * MAX_FLOPPY_DRIVES);
#endif
    for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
	drive *drv = &floppy[dr];
	/* reset all drive types to 3.5 DD */
	drive_settype_id (drv);
	if (!drive_insert (drv, &currprefs, dr, currprefs.df[dr]))
	    disk_eject (dr);
    }
    if (disk_empty (0))
	write_log ("No disk in drive 0.\n");
}

void DISK_reset (void)
{
    int i;

    if (savestate_state)
	return;

    //floppy[0].catweasel = &cwc.drives[0];
    disk_hpos = 0;
    dskdmaen = 0;
    disabled = 0;
    for (i = 0; i < MAX_FLOPPY_DRIVES; i++)
	reset_drive (i);
}

int DISK_examine_image (struct uae_prefs *p, int num, uae_u32 *crc32)
{
    unsigned int drvsec;
    unsigned int ret, i;
    drive *drv = &floppy[num];
    uae_u32 dos = 0;
    uae_u32 crc, crc2;

    ret = 0;
    drv->cyl = 0;
    side = 0;
    *crc32 = 0;
    if (!drive_insert (drv, p, num, p->df[num]))
	return 1;
    if (!drv->diskfile)
	return 1;
    *crc32 = zfile_crc32 (drv->diskfile);
    if (decode_buffer (drv->bigmfmbuf, drv->cyl, 11, drv->ddhd, drv->filetype, &drvsec, 1)) {
	ret = 2;
	goto end;
    }
    crc = crc2 = 0;
    for (i = 0; i < 1024; i += 4) {
	uae_u32 v = (writebuffer[i] << 24) | (writebuffer[i + 1] << 16) | (writebuffer[i + 2] << 8) | writebuffer[i + 3];
	if (i == 0)
	    dos = v;
	if (i == 4) {
	    crc2 = v;
	    v = 0;
	}
	if (crc + v < crc)
	    crc++;
	crc += v;
    }
    crc ^= 0xffffffff;
    if (crc != crc2)
	return 3;
    if (dos == 0x444f5300)
	ret = 10;
    else if (dos == 0x444f5301 || dos == 0x444f5302 || dos == 0x444f5303)
	ret = 11;
    else if (dos == 0x444f5304 || dos == 0x444f5305 || dos == 0x444f5306 || dos == 0x444f5307)
	ret = 12;
    else
	ret = 4;
end:
    drive_image_free (drv);
    return ret;
}


/* Disk save/restore code */

#if defined SAVESTATE || defined DEBUGGER

void DISK_save_custom (uae_u32 *pdskpt, uae_u16 *pdsklength, uae_u16 *pdsksync, uae_u16 *pdskbytr)
{
    if (pdskpt) *pdskpt = dskpt;
    if (pdsklength) *pdsklength = dsklength;
    if (pdsksync) *pdsksync = dsksync;
    if (pdskbytr) *pdskbytr = dskbytr_val;
}

#endif /* SAVESTATE || DEBUGGER */

#ifdef SAVESTATE

void DISK_restore_custom (uae_u32 pdskpt, uae_u16 pdsklength, uae_u16 pdskbytr)
{
    dskpt = pdskpt;
    dsklength = pdsklength;
    dskbytr_val = pdskbytr;
}

const uae_u8 *restore_disk (unsigned int num, const uae_u8 *src)
{
    drive *drv;
    int state, dfxtype;

    drv = &floppy[num];
    disabled &= ~(1 << num);
    drv->drive_id = restore_u32 ();
    drv->motoroff = 1;
    drv->idbit = 0;
    state = restore_u8 ();
    if (state & 2) {
	disabled |= 1 << num;
	if (changed_prefs.nr_floppies > (int)num)
	    changed_prefs.nr_floppies = num;
	changed_prefs.dfxtype[num] = -1;
    } else {
	drv->motoroff = (state & 1) ? 0 : 1;
	drv->idbit = (state & 4) ? 1 : 0;
	if (changed_prefs.nr_floppies < (int)num)
	    changed_prefs.nr_floppies = num;
	switch (drv->drive_id)
	{
	    case DRIVE_ID_35HD:
	    dfxtype = DRV_35_HD;
	    break;
	    case DRIVE_ID_525SD:
	    dfxtype = DRV_525_SD;
	    break;
	    default:
	    dfxtype = DRV_35_DD;
	    break;
	}
	changed_prefs.dfxtype[num] = dfxtype;
    }
    drv->cyl = restore_u8 ();
    drv->dskready = restore_u8 ();
    drv->drive_id_scnt = restore_u8 ();
    drv->mfmpos = restore_u32 ();
    drv->dskchange = 0;
    drv->dskchange_time = 0;
    restore_u32 ();
    strncpy (changed_prefs.df[num], (const char *)src, 255);
    src += strlen ((const char *)src) + 1;
    drive_insert (floppy + num, &currprefs, num, changed_prefs.df[num]);
    if (drive_empty (floppy + num))
	drv->dskchange = 1;

    return src;
}

static uae_u32 getadfcrc (drive *drv)
{
    uae_u8 *b;
    uae_u32 crc32;
    int size;

    if (!drv->diskfile)
	return 0;
    zfile_fseek (drv->diskfile, 0, SEEK_END);
    size = zfile_ftell (drv->diskfile);
    b = malloc (size);
    if (!b)
	return 0;
    zfile_fseek (drv->diskfile, 0, SEEK_SET);
    zfile_fread (b, 1, size, drv->diskfile);
    crc32 = get_crc32 (b, size);
    free (b);
    return crc32;
}

uae_u8 *save_disk (unsigned int num, uae_u32 *len, uae_u8 *dstptr)
{
    uae_u8 *dstbak,*dst;
    drive *drv;

    drv = &floppy[num];
    if (dstptr)
	dstbak = dst = dstptr;
    else
	dstbak = dst = malloc (2+1+1+1+1+4+4+256);
    save_u32 (drv->drive_id);	    /* drive type ID */
    save_u8 ((drv->motoroff ? 0:1) | ((disabled & (1 << num)) ? 2 : 0) | (drv->idbit ? 4 : 0));
    save_u8 (drv->cyl);		    /* cylinder */
    save_u8 (drv->dskready);	    /* dskready */
    save_u8 (drv->drive_id_scnt);   /* id mode position */
    save_u32 (drv->mfmpos);	    /* disk position */
    save_u32 (getadfcrc (drv));	    /* CRC of disk image */
    strcpy ((char *) dst, currprefs.df[num]);/* image name */
    dst += strlen ((const char *)dst) + 1;

    *len = dst - dstbak;
    return dstbak;
}

/* internal floppy controller variables */

const uae_u8 *restore_floppy (const uae_u8 *src)
{
    word = restore_u16 ();
    bitoffset = restore_u8 ();
    dma_enable = restore_u8 ();
    disk_hpos = restore_u8 () << 8;
    dskdmaen = restore_u8 ();
    restore_u16 ();
    //word |= restore_u16 () << 16;

    return src;
}

uae_u8 *save_floppy (uae_u32 *len, uae_u8 *dstptr)
{
    uae_u8 *dstbak, *dst;

    /* flush dma buffer before saving */
#if 0
    dodmafetch ();
#endif
    if (dstptr)
	dstbak = dst = dstptr;
    else
	dstbak = dst = malloc (2 + 1 + 1 + 1 + 1 + 2);
    save_u16 (word);		/* current fifo (low word) */
    save_u8 (bitoffset);	/* dma bit offset */
    save_u8 (dma_enable);	/* disk sync found */
    save_u8 (disk_hpos >> 8);	/* next bit read position */
    save_u8 (dskdmaen);		/* dma status */
    save_u16 (0);		/* was current fifo (high word), but it was wrong???? */

    *len = dst - dstbak;
    return dstbak;
}

#endif /* SAVESTATE */
